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 #include <dali/devel-api/events/key-event-devel.h>
 429
 430 #include <dali/public-api/math/matrix.h>
 431 #include <dali/public-api/math/matrix3.h>
 432 #include <dali/public-api/math/viewport.h>
 433 #include <dali/public-api/object/property-key.h>
 434 #include <dali/devel-api/object/csharp-type-info.h>
 435 #include <dali/devel-api/object/csharp-type-registry.h>
 436
 437 #include <dali/public-api/adaptor-framework/timer.h>
 438 #include <dali/public-api/adaptor-framework/style-change.h>
 439 #include <dali/devel-api/adaptor-framework/environment-variable.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 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 476 #include "web-view-signal-converter.h"
 477
 478
 479 // add here SWIG version check
 480
 481 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 482 // disable Swig-dependent warnings
 483
 484 // 'identifier1' has C-linkage specified,
 485 // but returns UDT 'identifier2' which is incompatible with C
 486 #pragma warning(disable: 4190)
 487
 488 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 489 #pragma warning(disable: 4800)
 490
 491 // debug info too long etc etc
 492 #pragma warning(disable: 4786)
 493 #endif
 494
 495
 496 #include <stdexcept>
 497
 498
 499 #include <string>
 500
 501
 502 #include <vector>
 503 #include <algorithm>
 504 #include <stdexcept>
 505
 506
 507 #include <map>
 508 #include <algorithm>
 509 #include <stdexcept>
 510
 511
 512 #include <utility>
 513
 514
 515 typedef float floatp;
 516
 517 SWIGINTERN floatp *new_floatp(){
 518   return new float();
 519 }
 520 SWIGINTERN void delete_floatp(floatp *self){
 521   if (self) delete self;
 522 }
 523 SWIGINTERN void floatp_assign(floatp *self,float value){
 524   *self = value;
 525 }
 526 SWIGINTERN float floatp_value(floatp *self){
 527   return *self;
 528 }
 529 SWIGINTERN float *floatp_cast(floatp *self){
 530   return self;
 531 }
 532 SWIGINTERN floatp *floatp_frompointer(float *t){
 533   return (floatp *) t;
 534 }
 535
 536 typedef int intp;
 537
 538 SWIGINTERN intp *new_intp(){
 539   return new int();
 540 }
 541 SWIGINTERN void delete_intp(intp *self){
 542   if (self) delete self;
 543 }
 544 SWIGINTERN void intp_assign(intp *self,int value){
 545   *self = value;
 546 }
 547 SWIGINTERN int intp_value(intp *self){
 548   return *self;
 549 }
 550 SWIGINTERN int *intp_cast(intp *self){
 551   return self;
 552 }
 553 SWIGINTERN intp *intp_frompointer(int *t){
 554   return (intp *) t;
 555 }
 556
 557 typedef double doublep;
 558
 559 SWIGINTERN doublep *new_doublep(){
 560   return new double();
 561 }
 562 SWIGINTERN void delete_doublep(doublep *self){
 563   if (self) delete self;
 564 }
 565 SWIGINTERN void doublep_assign(doublep *self,double value){
 566   *self = value;
 567 }
 568 SWIGINTERN double doublep_value(doublep *self){
 569   return *self;
 570 }
 571 SWIGINTERN double *doublep_cast(doublep *self){
 572   return self;
 573 }
 574 SWIGINTERN doublep *doublep_frompointer(double *t){
 575   return (doublep *) t;
 576 }
 577
 578 typedef unsigned int uintp;
 579
 580 SWIGINTERN uintp *new_uintp(){
 581   return new unsigned int();
 582 }
 583 SWIGINTERN void delete_uintp(uintp *self){
 584   if (self) delete self;
 585 }
 586 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 587   *self = value;
 588 }
 589 SWIGINTERN unsigned int uintp_value(uintp *self){
 590   return *self;
 591 }
 592 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 593   return self;
 594 }
 595 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 596   return (uintp *) t;
 597 }
 598
 599 typedef unsigned short ushortp;
 600
 601 SWIGINTERN ushortp *new_ushortp(){
 602   return new unsigned short();
 603 }
 604 SWIGINTERN void delete_ushortp(ushortp *self){
 605   if (self) delete self;
 606 }
 607 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 608   *self = value;
 609 }
 610 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 611   return *self;
 612 }
 613 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 614   return self;
 615 }
 616 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 617   return (ushortp *) t;
 618 }
 619
 620 unsigned int int_to_uint(int x) {
 621    return (unsigned int) x;
 622 }
 623
 624
 625 using namespace Dali;
 626 using namespace Dali::Toolkit;
 627
 628 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 629 {
 630   bool result = false;
 631   try
 632   {
 633     // C++ code. DALi uses Handle <-> Body design pattern.
 634     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 635     // Handles in DALi can be converted into a boolean type
 636     // to check if the handle has a valid body attached to it.
 637     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 638     if( *self )
 639     {
 640       result = true;
 641     }
 642     else
 643     {
 644       result = false;
 645     }
 646   }
 647   catch (std::out_of_range& e)
 648   {
 649     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 650     return 0;
 651   }
 652   catch (std::exception& e)
 653   {
 654     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 655     return 0;
 656   }
 657   catch (DaliException e)
 658   {
 659     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 660     return 0;
 661   }
 662   catch (...)
 663   {
 664     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 665     return 0;
 666   }
 667   return result;
 668 }
 669
 670 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 671 {
 672   bool result = false;
 673   try
 674   {
 675     // C++ code. Check if two handles reference the same implemtion
 676     if( *self == rhs)
 677     {
 678       result = true;
 679     }
 680     else
 681     {
 682       result = false;
 683     }
 684   }
 685   catch (std::out_of_range& e)
 686   {
 687     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 688     return 0;
 689   }
 690   catch (std::exception& e)
 691   {
 692     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 693     return 0;
 694   }
 695   catch (DaliException e)
 696   {
 697     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 698     return 0;
 699   }
 700   catch (...)
 701   {
 702     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 703     return 0;
 704   }
 705   return result;
 706 }
 707
 708
 709 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 710      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 711    }
 712 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){
 713      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 714    }
 715 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 716         std::vector< Dali::TouchPoint >* pv = 0;
 717         if (capacity >= 0) {
 718           pv = new std::vector< Dali::TouchPoint >();
 719           pv->reserve(capacity);
 720        } else {
 721           throw std::out_of_range("capacity");
 722        }
 723        return pv;
 724       }
 725 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 726         if (index>=0 && index<(int)self->size())
 727           return (*self)[index];
 728         else
 729           throw std::out_of_range("index");
 730       }
 731 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 732         if (index>=0 && index<(int)self->size())
 733           return (*self)[index];
 734         else
 735           throw std::out_of_range("index");
 736       }
 737 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 738         if (index>=0 && index<(int)self->size())
 739           (*self)[index] = val;
 740         else
 741           throw std::out_of_range("index");
 742       }
 743 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 744         self->insert(self->end(), values.begin(), values.end());
 745       }
 746 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 747         if (index < 0)
 748           throw std::out_of_range("index");
 749         if (count < 0)
 750           throw std::out_of_range("count");
 751         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 752           throw std::invalid_argument("invalid range");
 753         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 754       }
 755 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 756         if (index>=0 && index<(int)self->size()+1)
 757           self->insert(self->begin()+index, x);
 758         else
 759           throw std::out_of_range("index");
 760       }
 761 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 762         if (index>=0 && index<(int)self->size()+1)
 763           self->insert(self->begin()+index, values.begin(), values.end());
 764         else
 765           throw std::out_of_range("index");
 766       }
 767 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 768         if (index>=0 && index<(int)self->size())
 769           self->erase(self->begin() + index);
 770         else
 771           throw std::out_of_range("index");
 772       }
 773 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 774         if (index < 0)
 775           throw std::out_of_range("index");
 776         if (count < 0)
 777           throw std::out_of_range("count");
 778         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 779           throw std::invalid_argument("invalid range");
 780         self->erase(self->begin()+index, self->begin()+index+count);
 781       }
 782 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 783         if (count < 0)
 784           throw std::out_of_range("count");
 785         return new std::vector< Dali::TouchPoint >(count, value);
 786       }
 787 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 788         std::reverse(self->begin(), self->end());
 789       }
 790 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 791         if (index < 0)
 792           throw std::out_of_range("index");
 793         if (count < 0)
 794           throw std::out_of_range("count");
 795         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 796           throw std::invalid_argument("invalid range");
 797         std::reverse(self->begin()+index, self->begin()+index+count);
 798       }
 799 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 800         if (index < 0)
 801           throw std::out_of_range("index");
 802         if (index+values.size() > self->size())
 803           throw std::out_of_range("index");
 804         std::copy(values.begin(), values.end(), self->begin()+index);
 805       }
 806 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 807          return self->Empty();
 808       }
 809 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 810         return self->GetConnectionCount();
 811       }
 812 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 813           self->Connect( func );
 814       }
 815 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 816           self->Disconnect( func );
 817       }
 818 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 819           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 820 /*@SWIG@*/ self->Emit( arg );
 821       }
 822 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 823          return self->Empty();
 824       }
 825 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 826         return self->GetConnectionCount();
 827       }
 828 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 829           self->Connect( func );
 830       }
 831 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 832           self->Disconnect( func );
 833       }
 834 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 835           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 836 /*@SWIG@*/ self->Emit( arg );
 837       }
 838 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 839          return self->Empty();
 840       }
 841 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){
 842         return self->GetConnectionCount();
 843       }
 844 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 *)){
 845           self->Connect( func );
 846       }
 847 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 *)){
 848           self->Disconnect( func );
 849       }
 850 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){
 851           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 852 /*@SWIG@*/ self->Emit( arg );
 853       }
 854 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 855          return self->Empty();
 856       }
 857 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 858         return self->GetConnectionCount();
 859       }
 860 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 861           self->Connect( func );
 862       }
 863 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 864           self->Disconnect( func );
 865       }
 866 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 867           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 868 /*@SWIG@*/ self->Emit( arg );
 869       }
 870 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 871          return self->Empty();
 872       }
 873 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 874         return self->GetConnectionCount();
 875       }
 876 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 877           self->Connect( func );
 878       }
 879 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 880           self->Disconnect( func );
 881       }
 882 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 883           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 884 /*@SWIG@*/ self->Emit( arg );
 885       }
 886 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){
 887          return self->Empty();
 888       }
 889 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){
 890         return self->GetConnectionCount();
 891       }
 892 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 &)){
 893         self->Connect( func );
 894       }
 895 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 &)){
 896         self->Disconnect( func );
 897       }
 898 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){
 899         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 900 /*@SWIG@*/ self->Emit( arg1, arg2 );
 901       }
 902 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){
 903          return self->Empty();
 904       }
 905 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){
 906         return self->GetConnectionCount();
 907       }
 908 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 &)){
 909         self->Connect( func );
 910       }
 911 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 &)){
 912         self->Disconnect( func );
 913       }
 914 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){
 915         return self->Emit( arg1, arg2 );
 916       }
 917 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){
 918          return self->Empty();
 919       }
 920 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){
 921         return self->GetConnectionCount();
 922       }
 923 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 &)){
 924         self->Connect( func );
 925       }
 926 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 &)){
 927         self->Disconnect( func );
 928       }
 929 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){
 930         return self->Emit( arg1, arg2 );
 931       }
 932 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){
 933          return self->Empty();
 934       }
 935 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){
 936         return self->GetConnectionCount();
 937       }
 938 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 &)){
 939         self->Connect( func );
 940       }
 941 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 &)){
 942         self->Disconnect( func );
 943       }
 944 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){
 945         return self->Emit( arg1, arg2 );
 946       }
 947 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 948          return self->Empty();
 949       }
 950 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 951         return self->GetConnectionCount();
 952       }
 953 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 954           self->Connect( func );
 955       }
 956 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 957           self->Disconnect( func );
 958       }
 959 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 960           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 961 /*@SWIG@*/ self->Emit( arg );
 962       }
 963 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 964          return self->Empty();
 965       }
 966 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){
 967         return self->GetConnectionCount();
 968       }
 969 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 &)){
 970           self->Connect( func );
 971       }
 972 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 &)){
 973           self->Disconnect( func );
 974       }
 975 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){
 976           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 977 /*@SWIG@*/ self->Emit( arg );
 978       }
 979 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 980          return self->Empty();
 981       }
 982 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){
 983         return self->GetConnectionCount();
 984       }
 985 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 &)){
 986           self->Connect( func );
 987       }
 988 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 &)){
 989           self->Disconnect( func );
 990       }
 991 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){
 992           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 993 /*@SWIG@*/ self->Emit( arg );
 994       }
 995 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 996          return self->Empty();
 997       }
 998 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){
 999         return self->GetConnectionCount();
1000       }
1001 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 &)){
1002           self->Connect( func );
1003       }
1004 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 &)){
1005           self->Disconnect( func );
1006       }
1007 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){
1008           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1009 /*@SWIG@*/ self->Emit( arg );
1010       }
1011 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){
1012          return self->Empty();
1013       }
1014 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){
1015         return self->GetConnectionCount();
1016       }
1017 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 &)){
1018         self->Connect( func );
1019       }
1020 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 &)){
1021         self->Disconnect( func );
1022       }
1023 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){
1024         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1025 /*@SWIG@*/ self->Emit( arg1, arg2 );
1026       }
1027 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){
1028          return self->Empty();
1029       }
1030 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){
1031         return self->GetConnectionCount();
1032       }
1033 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 &)){
1034         self->Connect( func );
1035       }
1036 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 &)){
1037         self->Disconnect( func );
1038       }
1039 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){
1040         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1041 /*@SWIG@*/ self->Emit( arg1, arg2 );
1042       }
1043 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){
1044          return self->Empty();
1045       }
1046 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){
1047         return self->GetConnectionCount();
1048       }
1049 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 &)){
1050         self->Connect( func );
1051       }
1052 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 &)){
1053         self->Disconnect( func );
1054       }
1055 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){
1056         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1057 /*@SWIG@*/ self->Emit( arg1, arg2 );
1058       }
1059 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1060          return self->Empty();
1061       }
1062 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1063         return self->GetConnectionCount();
1064       }
1065 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1066           self->Connect( func );
1067       }
1068 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1069           self->Disconnect( func );
1070       }
1071 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1072           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1073 /*@SWIG@*/ self->Emit( arg );
1074       }
1075 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){
1076          return self->Empty();
1077       }
1078 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){
1079         return self->GetConnectionCount();
1080       }
1081 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)){
1082           return self->Connect( func );
1083       }
1084 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)){
1085           self->Disconnect( func );
1086       }
1087 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){
1088           self->Emit( arg1, arg3 );
1089       }
1090 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){
1091          return self->Empty();
1092       }
1093 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){
1094         return self->GetConnectionCount();
1095       }
1096 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)){
1097           return self->Connect( func );
1098       }
1099 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)){
1100           self->Disconnect( func );
1101       }
1102 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){
1103           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1104 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1105       }
1106
1107 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1108          return self->Empty();
1109       }
1110 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1111         return self->GetConnectionCount();
1112       }
1113 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1114           self->Connect( func );
1115       }
1116 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1117           self->Disconnect( func );
1118       }
1119 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1120           return self->Emit();
1121       }
1122
1123 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1124         std::vector< unsigned int >* pv = 0;
1125         if (capacity >= 0) {
1126           pv = new std::vector< unsigned int >();
1127           pv->reserve(capacity);
1128        } else {
1129           throw std::out_of_range("capacity");
1130        }
1131        return pv;
1132       }
1133 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1134         if (index>=0 && index<(int)self->size())
1135           return (*self)[index];
1136         else
1137           throw std::out_of_range("index");
1138       }
1139 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1140         if (index>=0 && index<(int)self->size())
1141           return (*self)[index];
1142         else
1143           throw std::out_of_range("index");
1144       }
1145 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1146         if (index>=0 && index<(int)self->size())
1147           (*self)[index] = val;
1148         else
1149           throw std::out_of_range("index");
1150       }
1151 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1152         self->insert(self->end(), values.begin(), values.end());
1153       }
1154 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1155         if (index < 0)
1156           throw std::out_of_range("index");
1157         if (count < 0)
1158           throw std::out_of_range("count");
1159         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1160           throw std::invalid_argument("invalid range");
1161         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1162       }
1163 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1164         if (index>=0 && index<(int)self->size()+1)
1165           self->insert(self->begin()+index, x);
1166         else
1167           throw std::out_of_range("index");
1168       }
1169 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1170         if (index>=0 && index<(int)self->size()+1)
1171           self->insert(self->begin()+index, values.begin(), values.end());
1172         else
1173           throw std::out_of_range("index");
1174       }
1175 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1176         if (index>=0 && index<(int)self->size())
1177           self->erase(self->begin() + index);
1178         else
1179           throw std::out_of_range("index");
1180       }
1181 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1182         if (index < 0)
1183           throw std::out_of_range("index");
1184         if (count < 0)
1185           throw std::out_of_range("count");
1186         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1187           throw std::invalid_argument("invalid range");
1188         self->erase(self->begin()+index, self->begin()+index+count);
1189       }
1190 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1191         if (count < 0)
1192           throw std::out_of_range("count");
1193         return new std::vector< unsigned int >(count, value);
1194       }
1195 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1196         std::reverse(self->begin(), self->end());
1197       }
1198 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1199         if (index < 0)
1200           throw std::out_of_range("index");
1201         if (count < 0)
1202           throw std::out_of_range("count");
1203         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1204           throw std::invalid_argument("invalid range");
1205         std::reverse(self->begin()+index, self->begin()+index+count);
1206       }
1207 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1208         if (index < 0)
1209           throw std::out_of_range("index");
1210         if (index+values.size() > self->size())
1211           throw std::out_of_range("index");
1212         std::copy(values.begin(), values.end(), self->begin()+index);
1213       }
1214 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1215         return std::find(self->begin(), self->end(), value) != self->end();
1216       }
1217 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1218         int index = -1;
1219         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1220         if (it != self->end())
1221           index = (int)(it - self->begin());
1222         return index;
1223       }
1224 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1225         int index = -1;
1226         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1227         if (rit != self->rend())
1228           index = (int)(self->rend() - 1 - rit);
1229         return index;
1230       }
1231 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1232         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1233         if (it != self->end()) {
1234           self->erase(it);
1235           return true;
1236         }
1237         return false;
1238       }
1239 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){
1240         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1241         if (capacity >= 0) {
1242           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1243           pv->reserve(capacity);
1244        } else {
1245           throw std::out_of_range("capacity");
1246        }
1247        return pv;
1248       }
1249 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){
1250         if (index>=0 && index<(int)self->size())
1251           return (*self)[index];
1252         else
1253           throw std::out_of_range("index");
1254       }
1255 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){
1256         if (index>=0 && index<(int)self->size())
1257           return (*self)[index];
1258         else
1259           throw std::out_of_range("index");
1260       }
1261 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){
1262         if (index>=0 && index<(int)self->size())
1263           (*self)[index] = val;
1264         else
1265           throw std::out_of_range("index");
1266       }
1267 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){
1268         self->insert(self->end(), values.begin(), values.end());
1269       }
1270 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){
1271         if (index < 0)
1272           throw std::out_of_range("index");
1273         if (count < 0)
1274           throw std::out_of_range("count");
1275         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1276           throw std::invalid_argument("invalid range");
1277         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1278       }
1279 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){
1280         if (index>=0 && index<(int)self->size()+1)
1281           self->insert(self->begin()+index, x);
1282         else
1283           throw std::out_of_range("index");
1284       }
1285 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){
1286         if (index>=0 && index<(int)self->size()+1)
1287           self->insert(self->begin()+index, values.begin(), values.end());
1288         else
1289           throw std::out_of_range("index");
1290       }
1291 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){
1292         if (index>=0 && index<(int)self->size())
1293           self->erase(self->begin() + index);
1294         else
1295           throw std::out_of_range("index");
1296       }
1297 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){
1298         if (index < 0)
1299           throw std::out_of_range("index");
1300         if (count < 0)
1301           throw std::out_of_range("count");
1302         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1303           throw std::invalid_argument("invalid range");
1304         self->erase(self->begin()+index, self->begin()+index+count);
1305       }
1306 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){
1307         if (count < 0)
1308           throw std::out_of_range("count");
1309         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1310       }
1311 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){
1312         std::reverse(self->begin(), self->end());
1313       }
1314 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){
1315         if (index < 0)
1316           throw std::out_of_range("index");
1317         if (count < 0)
1318           throw std::out_of_range("count");
1319         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1320           throw std::invalid_argument("invalid range");
1321         std::reverse(self->begin()+index, self->begin()+index+count);
1322       }
1323 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){
1324         if (index < 0)
1325           throw std::out_of_range("index");
1326         if (index+values.size() > self->size())
1327           throw std::out_of_range("index");
1328         std::copy(values.begin(), values.end(), self->begin()+index);
1329       }
1330 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1331         std::vector< Dali::Actor >* pv = 0;
1332         if (capacity >= 0) {
1333           pv = new std::vector< Dali::Actor >();
1334           pv->reserve(capacity);
1335        } else {
1336           throw std::out_of_range("capacity");
1337        }
1338        return pv;
1339       }
1340 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1341         if (index>=0 && index<(int)self->size())
1342           return (*self)[index];
1343         else
1344           throw std::out_of_range("index");
1345       }
1346 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1347         if (index>=0 && index<(int)self->size())
1348           return (*self)[index];
1349         else
1350           throw std::out_of_range("index");
1351       }
1352 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1353         if (index>=0 && index<(int)self->size())
1354           (*self)[index] = val;
1355         else
1356           throw std::out_of_range("index");
1357       }
1358 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1359         self->insert(self->end(), values.begin(), values.end());
1360       }
1361 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1362         if (index < 0)
1363           throw std::out_of_range("index");
1364         if (count < 0)
1365           throw std::out_of_range("count");
1366         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1367           throw std::invalid_argument("invalid range");
1368         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1369       }
1370 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1371         if (index>=0 && index<(int)self->size()+1)
1372           self->insert(self->begin()+index, x);
1373         else
1374           throw std::out_of_range("index");
1375       }
1376 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1377         if (index>=0 && index<(int)self->size()+1)
1378           self->insert(self->begin()+index, values.begin(), values.end());
1379         else
1380           throw std::out_of_range("index");
1381       }
1382 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1383         if (index>=0 && index<(int)self->size())
1384           self->erase(self->begin() + index);
1385         else
1386           throw std::out_of_range("index");
1387       }
1388 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1389         if (index < 0)
1390           throw std::out_of_range("index");
1391         if (count < 0)
1392           throw std::out_of_range("count");
1393         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1394           throw std::invalid_argument("invalid range");
1395         self->erase(self->begin()+index, self->begin()+index+count);
1396       }
1397 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1398         if (count < 0)
1399           throw std::out_of_range("count");
1400         return new std::vector< Dali::Actor >(count, value);
1401       }
1402 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1403         std::reverse(self->begin(), self->end());
1404       }
1405 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1406         if (index < 0)
1407           throw std::out_of_range("index");
1408         if (count < 0)
1409           throw std::out_of_range("count");
1410         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1411           throw std::invalid_argument("invalid range");
1412         std::reverse(self->begin()+index, self->begin()+index+count);
1413       }
1414 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1415         if (index < 0)
1416           throw std::out_of_range("index");
1417         if (index+values.size() > self->size())
1418           throw std::out_of_range("index");
1419         std::copy(values.begin(), values.end(), self->begin()+index);
1420       }
1421 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1422          return self->Empty();
1423       }
1424 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1425         return self->GetConnectionCount();
1426       }
1427 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 &)){
1428           self->Connect( func );
1429       }
1430 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 &)){
1431           self->Disconnect( func );
1432       }
1433 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){
1434           return self->Emit( arg );
1435       }
1436 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){
1437          return self->Empty();
1438       }
1439 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){
1440         return self->GetConnectionCount();
1441       }
1442 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)){
1443         self->Connect( func );
1444       }
1445 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)){
1446         self->Disconnect( func );
1447       }
1448 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){
1449         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1450 /*@SWIG@*/ self->Emit( arg1, arg2 );
1451       }
1452 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1453          return self->Empty();
1454       }
1455 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){
1456         return self->GetConnectionCount();
1457       }
1458 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)){
1459         self->Connect( func );
1460       }
1461 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)){
1462         self->Disconnect( func );
1463       }
1464 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){
1465         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1466 /*@SWIG@*/ self->Emit( arg1, arg2 );
1467       }
1468 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1469          return self->Empty();
1470       }
1471 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1472         return self->GetConnectionCount();
1473       }
1474 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)){
1475         self->Connect( func );
1476       }
1477 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)){
1478         self->Disconnect( func );
1479       }
1480 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){
1481         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1482 /*@SWIG@*/ self->Emit( arg1, arg2 );
1483       }
1484 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){
1485          return self->Empty();
1486       }
1487 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){
1488         return self->GetConnectionCount();
1489       }
1490 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)){
1491         self->Connect( func );
1492       }
1493 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)){
1494         self->Disconnect( func );
1495       }
1496 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){
1497         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1498 /*@SWIG@*/ self->Emit( arg1, arg2 );
1499       }
1500 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1501          return self->Empty();
1502       }
1503 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1504         return self->GetConnectionCount();
1505       }
1506 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)){
1507           self->Connect( func );
1508       }
1509 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)){
1510           self->Disconnect( func );
1511       }
1512 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1513           return self->Emit( arg );
1514       }
1515 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1516          return self->Empty();
1517       }
1518 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1519         return self->GetConnectionCount();
1520       }
1521 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)){
1522           self->Connect( func );
1523       }
1524 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)){
1525           self->Disconnect( func );
1526       }
1527 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1528           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1529 /*@SWIG@*/ self->Emit( arg );
1530       }
1531 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){
1532          return self->Empty();
1533       }
1534 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){
1535         return self->GetConnectionCount();
1536       }
1537 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)){
1538           return self->Connect( func );
1539       }
1540 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)){
1541           self->Disconnect( func );
1542       }
1543 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){
1544           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1545 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1546       }
1547 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1548          return self->Empty();
1549       }
1550 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1551         return self->GetConnectionCount();
1552       }
1553 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)){
1554           self->Connect( func );
1555       }
1556 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)){
1557           self->Disconnect( func );
1558       }
1559 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1560           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1561 /*@SWIG@*/ self->Emit( arg );
1562       }
1563 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){
1564          return self->Empty();
1565       }
1566 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){
1567         return self->GetConnectionCount();
1568       }
1569 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)){
1570           return self->Connect( func );
1571       }
1572 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)){
1573           self->Disconnect( func );
1574       }
1575 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){
1576           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1577 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1578       }
1579 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){
1580          return self->Empty();
1581       }
1582 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){
1583         return self->GetConnectionCount();
1584       }
1585 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 &)){
1586           self->Connect( func );
1587       }
1588 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 &)){
1589           self->Disconnect( func );
1590       }
1591 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){
1592           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1593 /*@SWIG@*/ self->Emit( arg );
1594       }
1595 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1596          return self->Empty();
1597       }
1598 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){
1599         return self->GetConnectionCount();
1600       }
1601 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 &)){
1602           self->Connect( func );
1603       }
1604 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 &)){
1605           self->Disconnect( func );
1606       }
1607 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){
1608           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1609 /*@SWIG@*/ self->Emit( arg );
1610       }
1611
1612
1613 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){
1614          return self->Empty();
1615       }
1616 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){
1617         return self->GetConnectionCount();
1618       }
1619 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 &)){
1620         self->Connect( func );
1621       }
1622 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 &)){
1623         self->Disconnect( func );
1624       }
1625 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){
1626         return self->Emit( arg1, arg2 );
1627       }
1628 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1629          return self->Empty();
1630       }
1631 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1632         return self->GetConnectionCount();
1633       }
1634 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)){
1635           self->Connect( func );
1636       }
1637 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)){
1638           self->Disconnect( func );
1639       }
1640 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1641           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1642 /*@SWIG@*/ self->Emit( arg );
1643       }
1644 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1645          return self->Empty();
1646       }
1647 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1648         return self->GetConnectionCount();
1649       }
1650 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 &)){
1651           self->Connect( func );
1652       }
1653 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 &)){
1654           self->Disconnect( func );
1655       }
1656 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){
1657           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1658 /*@SWIG@*/ self->Emit( arg );
1659       }
1660 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1661          return self->Empty();
1662       }
1663 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){
1664         return self->GetConnectionCount();
1665       }
1666 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)){
1667         self->Connect( func );
1668       }
1669 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)){
1670         self->Disconnect( func );
1671       }
1672 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){
1673         return self->Emit( arg1, arg2 );
1674       }
1675 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1676          return self->Empty();
1677       }
1678 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){
1679         return self->GetConnectionCount();
1680       }
1681 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)){
1682         self->Connect( func );
1683       }
1684 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)){
1685         self->Disconnect( func );
1686       }
1687 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){
1688         return self->Emit( arg1, arg2 );
1689       }
1690
1691 /* ---------------------------------------------------
1692  * C++ director class methods
1693  * --------------------------------------------------- */
1694
1695 #include "dali_wrap.h"
1696
1697 /*
1698  *  Widget director
1699  */
1700 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1701   swig_init_callbacks();
1702 }
1703
1704 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1705 }
1706
1707 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1708   char * jcontentInfo = 0 ;
1709   void * jwindow  ;
1710
1711   if (!swig_callbackOnCreate) {
1712     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1713     return;
1714   } else {
1715     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1716     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1717     swig_callbackOnCreate(jcontentInfo, jwindow);
1718   }
1719 }
1720
1721 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1722   char * jcontentInfo = 0 ;
1723   int jtype  ;
1724
1725   if (!swig_callbackOnTerminate) {
1726     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1727     return;
1728   } else {
1729     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1730     jtype = (int)type;
1731     swig_callbackOnTerminate(jcontentInfo, jtype);
1732   }
1733 }
1734
1735 void SwigDirector_WidgetImpl::OnPause() {
1736   if (!swig_callbackOnPause) {
1737     Dali::Internal::Adaptor::Widget::OnPause();
1738     return;
1739   } else {
1740     swig_callbackOnPause();
1741   }
1742 }
1743
1744 void SwigDirector_WidgetImpl::OnResume() {
1745   if (!swig_callbackOnResume) {
1746     Dali::Internal::Adaptor::Widget::OnResume();
1747     return;
1748   } else {
1749     swig_callbackOnResume();
1750   }
1751 }
1752
1753 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1754   void * jwindow  ;
1755
1756   if (!swig_callbackOnResize) {
1757     Dali::Internal::Adaptor::Widget::OnResize(window);
1758     return;
1759   } else {
1760     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1761     swig_callbackOnResize(jwindow);
1762   }
1763 }
1764
1765 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1766   char * jcontentInfo = 0 ;
1767   int jforce  ;
1768
1769   if (!swig_callbackOnUpdate) {
1770     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1771     return;
1772   } else {
1773     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1774     jforce = force;
1775     swig_callbackOnUpdate(jcontentInfo, jforce);
1776   }
1777 }
1778
1779 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1780   void * jslotObserver = 0 ;
1781   void * jcallback = 0 ;
1782
1783   if (!swig_callbackSignalConnected) {
1784     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1785     return;
1786   } else {
1787     jslotObserver = (void *) slotObserver;
1788     jcallback = (void *) callback;
1789     swig_callbackSignalConnected(jslotObserver, jcallback);
1790   }
1791 }
1792
1793 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1794   void * jslotObserver = 0 ;
1795   void * jcallback = 0 ;
1796
1797   if (!swig_callbackSignalDisconnected) {
1798     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1799     return;
1800   } else {
1801     jslotObserver = (void *) slotObserver;
1802     jcallback = (void *) callback;
1803     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1804   }
1805 }
1806
1807 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) {
1808
1809   swig_callbackOnCreate = callbackOnCreate;
1810   swig_callbackOnTerminate = callbackOnTerminate;
1811   swig_callbackOnPause = callbackOnPause;
1812   swig_callbackOnResume = callbackOnResume;
1813   swig_callbackOnResize = callbackOnResize;
1814   swig_callbackOnUpdate = callbackOnUpdate;
1815   swig_callbackSignalConnected = callbackSignalConnected;
1816   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1817 }
1818
1819 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1820   swig_callbackOnCreate = 0;
1821   swig_callbackOnTerminate = 0;
1822   swig_callbackOnPause = 0;
1823   swig_callbackOnResume = 0;
1824   swig_callbackOnResize = 0;
1825   swig_callbackOnUpdate = 0;
1826   swig_callbackSignalConnected = 0;
1827   swig_callbackSignalDisconnected = 0;
1828 }
1829
1830
1831 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1832   swig_init_callbacks();
1833 }
1834
1835 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1836
1837 }
1838
1839
1840 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1841   int jdepth  ;
1842
1843   if (!swig_callbackOnStageConnection) {
1844     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1845     return;
1846   } else {
1847     jdepth = depth;
1848     swig_callbackOnStageConnection(jdepth);
1849   }
1850 }
1851
1852 void SwigDirector_ViewImpl::OnStageDisconnection() {
1853   if (!swig_callbackOnStageDisconnection) {
1854     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1855     return;
1856   } else {
1857     swig_callbackOnStageDisconnection();
1858   }
1859 }
1860
1861 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1862   void * jchild = 0 ;
1863
1864   if (!swig_callbackOnChildAdd) {
1865     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1866     return;
1867   } else {
1868     jchild = (Dali::Actor *) &child;
1869     swig_callbackOnChildAdd(jchild);
1870   }
1871 }
1872
1873 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1874   void * jchild = 0 ;
1875
1876   if (!swig_callbackOnChildRemove) {
1877     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1878     return;
1879   } else {
1880     jchild = (Dali::Actor *) &child;
1881     swig_callbackOnChildRemove(jchild);
1882   }
1883 }
1884
1885 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1886   int jindex  ;
1887   void * jpropertyValue  ;
1888
1889   if (!swig_callbackOnPropertySet) {
1890     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1891     return;
1892   } else {
1893     jindex = index;
1894     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1895     swig_callbackOnPropertySet(jindex, jpropertyValue);
1896   }
1897 }
1898
1899 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1900   void * jtargetSize = 0 ;
1901
1902   if (!swig_callbackOnSizeSet) {
1903     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1904     return;
1905   } else {
1906     jtargetSize = (Dali::Vector3 *) &targetSize;
1907     swig_callbackOnSizeSet(jtargetSize);
1908   }
1909 }
1910
1911 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1912   void * janimation = 0 ;
1913   void * jtargetSize = 0 ;
1914
1915   if (!swig_callbackOnSizeAnimation) {
1916     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1917     return;
1918   } else {
1919     janimation = (Dali::Animation *) &animation;
1920     jtargetSize = (Dali::Vector3 *) &targetSize;
1921     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1922   }
1923 }
1924
1925 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1926   bool c_result = SwigValueInit< bool >() ;
1927   unsigned int jresult = 0 ;
1928   void * jarg0 = 0 ;
1929
1930   if (!swig_callbackOnTouchEvent) {
1931     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1932   } else {
1933     jarg0 = (Dali::TouchEvent *) &event;
1934     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1935     c_result = jresult ? true : false;
1936   }
1937   return c_result;
1938 }
1939
1940 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1941   bool c_result = SwigValueInit< bool >() ;
1942   unsigned int jresult = 0 ;
1943   void * jarg0 = 0 ;
1944
1945   if (!swig_callbackOnHoverEvent) {
1946     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1947   } else {
1948     jarg0 = (Dali::HoverEvent *) &event;
1949     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1950     c_result = jresult ? true : false;
1951   }
1952   return c_result;
1953 }
1954
1955 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1956   bool c_result = SwigValueInit< bool >() ;
1957   unsigned int jresult = 0 ;
1958   void * jarg0 = 0 ;
1959
1960   if (!swig_callbackOnKeyEvent) {
1961     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1962   } else {
1963     jarg0 = (Dali::KeyEvent *) &event;
1964     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1965     c_result = jresult ? true : false;
1966   }
1967   return c_result;
1968 }
1969
1970 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1971   bool c_result = SwigValueInit< bool >() ;
1972   unsigned int jresult = 0 ;
1973   void * jarg0 = 0 ;
1974
1975   if (!swig_callbackOnWheelEvent) {
1976     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1977   } else {
1978     jarg0 = (Dali::WheelEvent *) &event;
1979     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1980     c_result = jresult ? true : false;
1981   }
1982   return c_result;
1983 }
1984
1985 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1986   void * jsize = 0 ;
1987   void * jcontainer = 0 ;
1988
1989   if (!swig_callbackOnRelayout) {
1990     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1991     return;
1992   } else {
1993     jsize = (Dali::Vector2 *) &size;
1994     jcontainer = (Dali::RelayoutContainer *) &container;
1995     swig_callbackOnRelayout(jsize, jcontainer);
1996   }
1997 }
1998
1999 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2000   int jpolicy  ;
2001   int jdimension  ;
2002
2003   if (!swig_callbackOnSetResizePolicy) {
2004     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2005     return;
2006   } else {
2007     jpolicy = (int)policy;
2008     jdimension = (int)dimension;
2009     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2010   }
2011 }
2012
2013 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2014   Dali::Vector3 c_result ;
2015   void * jresult = 0 ;
2016
2017   if (!swig_callbackGetNaturalSize) {
2018     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2019   } else {
2020     jresult = (void *) swig_callbackGetNaturalSize();
2021     if (!jresult) {
2022       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2023       return c_result;
2024     }
2025     c_result = *(Dali::Vector3 *)jresult;
2026   }
2027   return c_result;
2028 }
2029
2030 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2031   float c_result = SwigValueInit< float >() ;
2032   float jresult = 0 ;
2033   void * jchild = 0 ;
2034   int jdimension  ;
2035
2036   if (!swig_callbackCalculateChildSize) {
2037     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2038   } else {
2039     jchild = (Dali::Actor *) &child;
2040     jdimension = (int)dimension;
2041     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2042     c_result = (float)jresult;
2043   }
2044   return c_result;
2045 }
2046
2047 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2048   float c_result = SwigValueInit< float >() ;
2049   float jresult = 0 ;
2050   float jwidth  ;
2051
2052   if (!swig_callbackGetHeightForWidth) {
2053     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2054   } else {
2055     jwidth = width;
2056     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2057     c_result = (float)jresult;
2058   }
2059   return c_result;
2060 }
2061
2062 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2063   float c_result = SwigValueInit< float >() ;
2064   float jresult = 0 ;
2065   float jheight  ;
2066
2067   if (!swig_callbackGetWidthForHeight) {
2068     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2069   } else {
2070     jheight = height;
2071     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2072     c_result = (float)jresult;
2073   }
2074   return c_result;
2075 }
2076
2077 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2078   bool c_result = SwigValueInit< bool >() ;
2079   unsigned int jresult = 0 ;
2080   int jdimension  ;
2081
2082   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2083     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2084   } else {
2085     jdimension = (int)dimension;
2086     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2087     c_result = jresult ? true : false;
2088   }
2089   return c_result;
2090 }
2091
2092 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2093   int jdimension  ;
2094
2095   if (!swig_callbackOnCalculateRelayoutSize) {
2096     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2097     return;
2098   } else {
2099     jdimension = (int)dimension;
2100     swig_callbackOnCalculateRelayoutSize(jdimension);
2101   }
2102 }
2103
2104 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2105   float jsize  ;
2106   int jdimension  ;
2107
2108   if (!swig_callbackOnLayoutNegotiated) {
2109     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2110     return;
2111   } else {
2112     jsize = size;
2113     jdimension = (int)dimension;
2114     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2115   }
2116 }
2117
2118 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2119   return Dali::CustomActorImpl::GetExtension();
2120 }
2121
2122 void SwigDirector_ViewImpl::OnInitialize() {
2123   if (!swig_callbackOnInitialize) {
2124     Dali::Toolkit::Internal::Control::OnInitialize();
2125     return;
2126   } else {
2127     swig_callbackOnInitialize();
2128   }
2129 }
2130
2131 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2132   void * jchild = 0 ;
2133
2134   if (!swig_callbackOnControlChildAdd) {
2135     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2136     return;
2137   } else {
2138     jchild = (Dali::Actor *) &child;
2139     swig_callbackOnControlChildAdd(jchild);
2140   }
2141 }
2142
2143 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2144   void * jchild = 0 ;
2145
2146   if (!swig_callbackOnControlChildRemove) {
2147     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2148     return;
2149   } else {
2150     jchild = (Dali::Actor *) &child;
2151     swig_callbackOnControlChildRemove(jchild);
2152   }
2153 }
2154
2155 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2156   void * jstyleManager  ;
2157   int jchange  ;
2158
2159   if (!swig_callbackOnStyleChange) {
2160     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2161     return;
2162   } else {
2163     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2164     jchange = (int)change;
2165     swig_callbackOnStyleChange(jstyleManager, jchange);
2166   }
2167 }
2168
2169 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2170   bool c_result = SwigValueInit< bool >() ;
2171   unsigned int jresult = 0 ;
2172
2173   if (!swig_callbackOnAccessibilityActivated) {
2174     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2175   } else {
2176     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2177     c_result = jresult ? true : false;
2178   }
2179   return c_result;
2180 }
2181
2182 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2183   bool c_result = SwigValueInit< bool >() ;
2184   unsigned int jresult = 0 ;
2185   void * jgesture  ;
2186
2187   if (!swig_callbackOnAccessibilityPan) {
2188     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2189   } else {
2190     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2191     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2192     c_result = jresult ? true : false;
2193   }
2194   return c_result;
2195 }
2196
2197 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2198   bool c_result = SwigValueInit< bool >() ;
2199   unsigned int jresult = 0 ;
2200   void * jtouchEvent = 0 ;
2201
2202   if (!swig_callbackOnAccessibilityTouch) {
2203     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2204   } else {
2205     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2206     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2207     c_result = jresult ? true : false;
2208   }
2209   return c_result;
2210 }
2211
2212 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2213   bool c_result = SwigValueInit< bool >() ;
2214   unsigned int jresult = 0 ;
2215   unsigned int jisIncrease  ;
2216
2217   if (!swig_callbackOnAccessibilityValueChange) {
2218     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2219   } else {
2220     jisIncrease = isIncrease;
2221     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2222     c_result = jresult ? true : false;
2223   }
2224   return c_result;
2225 }
2226
2227 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2228   bool c_result = SwigValueInit< bool >() ;
2229   unsigned int jresult = 0 ;
2230
2231   if (!swig_callbackOnAccessibilityZoom) {
2232     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2233   } else {
2234     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2235     c_result = jresult ? true : false;
2236   }
2237   return c_result;
2238 }
2239
2240 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2241   if (!swig_callbackOnKeyInputFocusGained) {
2242     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2243     return;
2244   } else {
2245     swig_callbackOnKeyInputFocusGained();
2246   }
2247 }
2248
2249 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2250   if (!swig_callbackOnKeyInputFocusLost) {
2251     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2252     return;
2253   } else {
2254     swig_callbackOnKeyInputFocusLost();
2255   }
2256 }
2257
2258 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2259   Dali::Actor c_result ;
2260   void * jresult = 0 ;
2261   void * jcurrentFocusedActor  ;
2262   int jdirection  ;
2263   unsigned int jloopEnabled  ;
2264
2265   if (!swig_callbackGetNextKeyboardFocusableActor) {
2266     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2267   } else {
2268     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2269     jdirection = (int)direction;
2270     jloopEnabled = loopEnabled;
2271     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2272     if (!jresult) {
2273       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2274       return c_result;
2275     }
2276     c_result = *(Dali::Actor *)jresult;
2277   }
2278   return c_result;
2279 }
2280
2281 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2282   void * jcommitedFocusableActor  ;
2283
2284   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2285     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2286     return;
2287   } else {
2288     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2289     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2290   }
2291 }
2292
2293 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2294   bool c_result = SwigValueInit< bool >() ;
2295   unsigned int jresult = 0 ;
2296
2297   if (!swig_callbackOnKeyboardEnter) {
2298     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2299   } else {
2300     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2301     c_result = jresult ? true : false;
2302   }
2303   return c_result;
2304 }
2305
2306 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2307   void * jpinch = 0 ;
2308
2309   if (!swig_callbackOnPinch) {
2310     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2311     return;
2312   } else {
2313     jpinch = (Dali::PinchGesture *) &pinch;
2314     swig_callbackOnPinch(jpinch);
2315   }
2316 }
2317
2318 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2319   void * jpan = 0 ;
2320
2321   if (!swig_callbackOnPan) {
2322     Dali::Toolkit::Internal::Control::OnPan(pan);
2323     return;
2324   } else {
2325     jpan = (Dali::PanGesture *) &pan;
2326     swig_callbackOnPan(jpan);
2327   }
2328 }
2329
2330 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2331   void * jtap = 0 ;
2332
2333   if (!swig_callbackOnTap) {
2334     Dali::Toolkit::Internal::Control::OnTap(tap);
2335     return;
2336   } else {
2337     jtap = (Dali::TapGesture *) &tap;
2338     swig_callbackOnTap(jtap);
2339   }
2340 }
2341
2342 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2343   void * jlongPress = 0 ;
2344
2345   if (!swig_callbackOnLongPress) {
2346     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2347     return;
2348   } else {
2349     jlongPress = (Dali::LongPressGesture *) &longPress;
2350     swig_callbackOnLongPress(jlongPress);
2351   }
2352 }
2353
2354 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2355   void * jslotObserver = 0 ;
2356   void * jcallback = 0 ;
2357
2358   if (!swig_callbackSignalConnected) {
2359     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2360     return;
2361   } else {
2362     jslotObserver = (void *) slotObserver;
2363     jcallback = (void *) callback;
2364     swig_callbackSignalConnected(jslotObserver, jcallback);
2365   }
2366 }
2367
2368 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2369   void * jslotObserver = 0 ;
2370   void * jcallback = 0 ;
2371
2372   if (!swig_callbackSignalDisconnected) {
2373     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2374     return;
2375   } else {
2376     jslotObserver = (void *) slotObserver;
2377     jcallback = (void *) callback;
2378     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2379   }
2380 }
2381
2382 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2383   return Dali::Toolkit::Internal::Control::GetControlExtension();
2384 }
2385
2386 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) {
2387   swig_callbackOnStageConnection = callbackOnStageConnection;
2388   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2389   swig_callbackOnChildAdd = callbackOnChildAdd;
2390   swig_callbackOnChildRemove = callbackOnChildRemove;
2391   swig_callbackOnPropertySet = callbackOnPropertySet;
2392   swig_callbackOnSizeSet = callbackOnSizeSet;
2393   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2394   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2395   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2396   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2397   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2398   swig_callbackOnRelayout = callbackOnRelayout;
2399   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2400   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2401   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2402   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2403   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2404   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2405   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2406   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2407   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2408   swig_callbackOnInitialize = callbackOnInitialize;
2409   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2410   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2411   swig_callbackOnStyleChange = callbackOnStyleChange;
2412   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2413   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2414   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2415   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2416   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2417   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2418   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2419   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2420   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2421   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2422   swig_callbackOnPinch = callbackOnPinch;
2423   swig_callbackOnPan = callbackOnPan;
2424   swig_callbackOnTap = callbackOnTap;
2425   swig_callbackOnLongPress = callbackOnLongPress;
2426   swig_callbackSignalConnected = callbackSignalConnected;
2427   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2428 }
2429
2430 void SwigDirector_ViewImpl::swig_init_callbacks() {
2431   swig_callbackOnStageConnection = 0;
2432   swig_callbackOnStageDisconnection = 0;
2433   swig_callbackOnChildAdd = 0;
2434   swig_callbackOnChildRemove = 0;
2435   swig_callbackOnPropertySet = 0;
2436   swig_callbackOnSizeSet = 0;
2437   swig_callbackOnSizeAnimation = 0;
2438   swig_callbackOnTouchEvent = 0;
2439   swig_callbackOnHoverEvent = 0;
2440   swig_callbackOnKeyEvent = 0;
2441   swig_callbackOnWheelEvent = 0;
2442   swig_callbackOnRelayout = 0;
2443   swig_callbackOnSetResizePolicy = 0;
2444   swig_callbackGetNaturalSize = 0;
2445   swig_callbackCalculateChildSize = 0;
2446   swig_callbackGetHeightForWidth = 0;
2447   swig_callbackGetWidthForHeight = 0;
2448   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2449   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2450   swig_callbackOnCalculateRelayoutSize = 0;
2451   swig_callbackOnLayoutNegotiated = 0;
2452   swig_callbackOnInitialize = 0;
2453   swig_callbackOnControlChildAdd = 0;
2454   swig_callbackOnControlChildRemove = 0;
2455   swig_callbackOnStyleChange = 0;
2456   swig_callbackOnAccessibilityActivated = 0;
2457   swig_callbackOnAccessibilityPan = 0;
2458   swig_callbackOnAccessibilityTouch = 0;
2459   swig_callbackOnAccessibilityValueChange = 0;
2460   swig_callbackOnAccessibilityZoom = 0;
2461   swig_callbackOnKeyInputFocusGained = 0;
2462   swig_callbackOnKeyInputFocusLost = 0;
2463   swig_callbackGetNextKeyboardFocusableActor = 0;
2464   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2465   swig_callbackOnKeyboardEnter = 0;
2466   swig_callbackOnPinch = 0;
2467   swig_callbackOnPan = 0;
2468   swig_callbackOnTap = 0;
2469   swig_callbackOnLongPress = 0;
2470   swig_callbackSignalConnected = 0;
2471   swig_callbackSignalDisconnected = 0;
2472 }
2473
2474 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2475   swig_init_callbacks();
2476 }
2477
2478 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2479
2480 }
2481
2482
2483 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2484   unsigned int c_result = SwigValueInit< unsigned int >() ;
2485   unsigned int jresult = 0 ;
2486
2487   if (!swig_callbackGetNumberOfItems) {
2488     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2489   } else {
2490     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2491     c_result = (unsigned int)jresult;
2492   }
2493   return c_result;
2494 }
2495
2496 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2497   Dali::Actor c_result ;
2498   void * jresult = 0 ;
2499   unsigned int jitemId  ;
2500
2501   if (!swig_callbackNewItem) {
2502     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2503   } else {
2504     jitemId = itemId;
2505     jresult = (void *) swig_callbackNewItem(jitemId);
2506     if (!jresult) {
2507       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2508       return c_result;
2509     }
2510     c_result = *(Dali::Actor *)jresult;
2511   }
2512   return c_result;
2513 }
2514
2515 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2516   unsigned int jitemId  ;
2517   void * jactor  ;
2518
2519   if (!swig_callbackItemReleased) {
2520     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2521     return;
2522   } else {
2523     jitemId = itemId;
2524     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2525     swig_callbackItemReleased(jitemId, jactor);
2526   }
2527 }
2528
2529 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2530   return Dali::Toolkit::ItemFactory::GetExtension();
2531 }
2532
2533 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2534   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2535   swig_callbackNewItem = callbackNewItem;
2536   swig_callbackItemReleased = callbackItemReleased;
2537 }
2538
2539 void SwigDirector_ItemFactory::swig_init_callbacks() {
2540   swig_callbackGetNumberOfItems = 0;
2541   swig_callbackNewItem = 0;
2542   swig_callbackItemReleased = 0;
2543 }
2544
2545 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2546   swig_init_callbacks();
2547 }
2548
2549 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2550
2551 }
2552
2553
2554 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2555   Dali::Actor c_result ;
2556   void * jresult = 0 ;
2557   void * jcurrent  ;
2558   void * jproposed  ;
2559   int jdirection  ;
2560
2561   if (!swig_callbackGetNextFocusableActor) {
2562     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2563   } else {
2564     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2565     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2566     jdirection = (int)direction;
2567     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2568     if (!jresult) {
2569       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2570       return c_result;
2571     }
2572     c_result = *(Dali::Actor *)jresult;
2573   }
2574   return c_result;
2575 }
2576
2577 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2578   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2579 }
2580
2581 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2582   swig_callbackGetNextFocusableActor = 0;
2583 }
2584
2585
2586 #ifdef __cplusplus
2587 extern "C" {
2588 #endif
2589
2590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2591   void * jresult ;
2592   floatp *result = 0 ;
2593
2594   {
2595     try {
2596       result = (floatp *)new_floatp();
2597     } catch (std::out_of_range& e) {
2598       {
2599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2600       };
2601     } catch (std::exception& e) {
2602       {
2603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2604       };
2605     } catch (DaliException e) {
2606       {
2607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2608       };
2609     } catch (...) {
2610       {
2611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2612       };
2613     }
2614   }
2615   jresult = (void *)result;
2616   return jresult;
2617 }
2618
2619
2620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2621   floatp *arg1 = (floatp *) 0 ;
2622
2623   arg1 = (floatp *)jarg1;
2624   {
2625     try {
2626       delete_floatp(arg1);
2627     } catch (std::out_of_range& e) {
2628       {
2629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2630       };
2631     } catch (std::exception& e) {
2632       {
2633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2634       };
2635     } catch (Dali::DaliException e) {
2636       {
2637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2638       };
2639     } catch (...) {
2640       {
2641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2642       };
2643     }
2644   }
2645
2646 }
2647
2648
2649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2650   floatp *arg1 = (floatp *) 0 ;
2651   float arg2 ;
2652
2653   arg1 = (floatp *)jarg1;
2654   arg2 = (float)jarg2;
2655   {
2656     try {
2657       floatp_assign(arg1,arg2);
2658     } catch (std::out_of_range& e) {
2659       {
2660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2661       };
2662     } catch (std::exception& e) {
2663       {
2664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2665       };
2666     } catch (Dali::DaliException e) {
2667       {
2668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2669       };
2670     } catch (...) {
2671       {
2672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2673       };
2674     }
2675   }
2676
2677 }
2678
2679
2680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2681   float jresult ;
2682   floatp *arg1 = (floatp *) 0 ;
2683   float result;
2684
2685   arg1 = (floatp *)jarg1;
2686   {
2687     try {
2688       result = (float)floatp_value(arg1);
2689     } catch (std::out_of_range& e) {
2690       {
2691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2692       };
2693     } catch (std::exception& e) {
2694       {
2695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2696       };
2697     } catch (DaliException e) {
2698       {
2699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2700       };
2701     } catch (...) {
2702       {
2703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2704       };
2705     }
2706   }
2707   jresult = result;
2708   return jresult;
2709 }
2710
2711
2712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2713   void * jresult ;
2714   floatp *arg1 = (floatp *) 0 ;
2715   float *result = 0 ;
2716
2717   arg1 = (floatp *)jarg1;
2718   {
2719     try {
2720       result = (float *)floatp_cast(arg1);
2721     } catch (std::out_of_range& e) {
2722       {
2723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2724       };
2725     } catch (std::exception& e) {
2726       {
2727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2728       };
2729     } catch (Dali::DaliException e) {
2730       {
2731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2732       };
2733     } catch (...) {
2734       {
2735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2736       };
2737     }
2738   }
2739
2740   jresult = (void *)result;
2741   return jresult;
2742 }
2743
2744
2745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2746   void * jresult ;
2747   float *arg1 = (float *) 0 ;
2748   floatp *result = 0 ;
2749
2750   arg1 = (float *)jarg1;
2751   {
2752     try {
2753       result = (floatp *)floatp_frompointer(arg1);
2754     } catch (std::out_of_range& e) {
2755       {
2756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2757       };
2758     } catch (std::exception& e) {
2759       {
2760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2761       };
2762     } catch (Dali::DaliException e) {
2763       {
2764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2765       };
2766     } catch (...) {
2767       {
2768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2769       };
2770     }
2771   }
2772
2773   jresult = (void *)result;
2774   return jresult;
2775 }
2776
2777
2778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2779   void * jresult ;
2780   intp *result = 0 ;
2781
2782   {
2783     try {
2784       result = (intp *)new_intp();
2785     } catch (std::out_of_range& e) {
2786       {
2787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2788       };
2789     } catch (std::exception& e) {
2790       {
2791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2792       };
2793     } catch (Dali::DaliException e) {
2794       {
2795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2796       };
2797     } catch (...) {
2798       {
2799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2800       };
2801     }
2802   }
2803
2804   jresult = (void *)result;
2805   return jresult;
2806 }
2807
2808
2809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2810   intp *arg1 = (intp *) 0 ;
2811
2812   arg1 = (intp *)jarg1;
2813   {
2814     try {
2815       delete_intp(arg1);
2816     } catch (std::out_of_range& e) {
2817       {
2818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2819       };
2820     } catch (std::exception& e) {
2821       {
2822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2823       };
2824     } catch (Dali::DaliException e) {
2825       {
2826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2827       };
2828     } catch (...) {
2829       {
2830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2831       };
2832     }
2833   }
2834
2835 }
2836
2837
2838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2839   intp *arg1 = (intp *) 0 ;
2840   int arg2 ;
2841
2842   arg1 = (intp *)jarg1;
2843   arg2 = (int)jarg2;
2844   {
2845     try {
2846       intp_assign(arg1,arg2);
2847     } catch (std::out_of_range& e) {
2848       {
2849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2850       };
2851     } catch (std::exception& e) {
2852       {
2853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2854       };
2855     } catch (Dali::DaliException e) {
2856       {
2857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2858       };
2859     } catch (...) {
2860       {
2861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2862       };
2863     }
2864   }
2865
2866 }
2867
2868
2869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2870   int jresult ;
2871   intp *arg1 = (intp *) 0 ;
2872   int result;
2873
2874   arg1 = (intp *)jarg1;
2875   {
2876     try {
2877       result = (int)intp_value(arg1);
2878     } catch (std::out_of_range& e) {
2879       {
2880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2881       };
2882     } catch (std::exception& e) {
2883       {
2884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2885       };
2886     } catch (Dali::DaliException e) {
2887       {
2888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2889       };
2890     } catch (...) {
2891       {
2892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2893       };
2894     }
2895   }
2896
2897   jresult = result;
2898   return jresult;
2899 }
2900
2901
2902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2903   void * jresult ;
2904   intp *arg1 = (intp *) 0 ;
2905   int *result = 0 ;
2906
2907   arg1 = (intp *)jarg1;
2908   {
2909     try {
2910       result = (int *)intp_cast(arg1);
2911     } catch (std::out_of_range& e) {
2912       {
2913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2914       };
2915     } catch (std::exception& e) {
2916       {
2917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2918       };
2919     } catch (Dali::DaliException e) {
2920       {
2921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2922       };
2923     } catch (...) {
2924       {
2925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2926       };
2927     }
2928   }
2929
2930   jresult = (void *)result;
2931   return jresult;
2932 }
2933
2934
2935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2936   void * jresult ;
2937   int *arg1 = (int *) 0 ;
2938   intp *result = 0 ;
2939
2940   arg1 = (int *)jarg1;
2941   {
2942     try {
2943       result = (intp *)intp_frompointer(arg1);
2944     } catch (std::out_of_range& e) {
2945       {
2946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2947       };
2948     } catch (std::exception& e) {
2949       {
2950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2951       };
2952     } catch (Dali::DaliException e) {
2953       {
2954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2955       };
2956     } catch (...) {
2957       {
2958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2959       };
2960     }
2961   }
2962
2963   jresult = (void *)result;
2964   return jresult;
2965 }
2966
2967
2968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2969   void * jresult ;
2970   doublep *result = 0 ;
2971
2972   {
2973     try {
2974       result = (doublep *)new_doublep();
2975     } catch (std::out_of_range& e) {
2976       {
2977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2978       };
2979     } catch (std::exception& e) {
2980       {
2981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2982       };
2983     } catch (Dali::DaliException e) {
2984       {
2985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2986       };
2987     } catch (...) {
2988       {
2989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2990       };
2991     }
2992   }
2993
2994   jresult = (void *)result;
2995   return jresult;
2996 }
2997
2998
2999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3000   doublep *arg1 = (doublep *) 0 ;
3001
3002   arg1 = (doublep *)jarg1;
3003   {
3004     try {
3005       delete_doublep(arg1);
3006     } catch (std::out_of_range& e) {
3007       {
3008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3009       };
3010     } catch (std::exception& e) {
3011       {
3012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3013       };
3014     } catch (Dali::DaliException e) {
3015       {
3016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3017       };
3018     } catch (...) {
3019       {
3020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3021       };
3022     }
3023   }
3024
3025 }
3026
3027
3028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3029   doublep *arg1 = (doublep *) 0 ;
3030   double arg2 ;
3031
3032   arg1 = (doublep *)jarg1;
3033   arg2 = (double)jarg2;
3034   {
3035     try {
3036       doublep_assign(arg1,arg2);
3037     } catch (std::out_of_range& e) {
3038       {
3039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3040       };
3041     } catch (std::exception& e) {
3042       {
3043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3044       };
3045     } catch (Dali::DaliException e) {
3046       {
3047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3048       };
3049     } catch (...) {
3050       {
3051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3052       };
3053     }
3054   }
3055
3056 }
3057
3058
3059 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3060   double jresult ;
3061   doublep *arg1 = (doublep *) 0 ;
3062   double result;
3063
3064   arg1 = (doublep *)jarg1;
3065   {
3066     try {
3067       result = (double)doublep_value(arg1);
3068     } catch (std::out_of_range& e) {
3069       {
3070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3071       };
3072     } catch (std::exception& e) {
3073       {
3074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3075       };
3076     } catch (Dali::DaliException e) {
3077       {
3078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3079       };
3080     } catch (...) {
3081       {
3082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3083       };
3084     }
3085   }
3086
3087   jresult = result;
3088   return jresult;
3089 }
3090
3091
3092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3093   void * jresult ;
3094   doublep *arg1 = (doublep *) 0 ;
3095   double *result = 0 ;
3096
3097   arg1 = (doublep *)jarg1;
3098   {
3099     try {
3100       result = (double *)doublep_cast(arg1);
3101     } catch (std::out_of_range& e) {
3102       {
3103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3104       };
3105     } catch (std::exception& e) {
3106       {
3107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3108       };
3109     } catch (Dali::DaliException e) {
3110       {
3111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3112       };
3113     } catch (...) {
3114       {
3115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3116       };
3117     }
3118   }
3119
3120   jresult = (void *)result;
3121   return jresult;
3122 }
3123
3124
3125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3126   void * jresult ;
3127   double *arg1 = (double *) 0 ;
3128   doublep *result = 0 ;
3129
3130   arg1 = (double *)jarg1;
3131   {
3132     try {
3133       result = (doublep *)doublep_frompointer(arg1);
3134     } catch (std::out_of_range& e) {
3135       {
3136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3137       };
3138     } catch (std::exception& e) {
3139       {
3140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3141       };
3142     } catch (Dali::DaliException e) {
3143       {
3144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3145       };
3146     } catch (...) {
3147       {
3148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3149       };
3150     }
3151   }
3152
3153   jresult = (void *)result;
3154   return jresult;
3155 }
3156
3157
3158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3159   void * jresult ;
3160   uintp *result = 0 ;
3161
3162   {
3163     try {
3164       result = (uintp *)new_uintp();
3165     } catch (std::out_of_range& e) {
3166       {
3167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3168       };
3169     } catch (std::exception& e) {
3170       {
3171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3172       };
3173     } catch (Dali::DaliException e) {
3174       {
3175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3176       };
3177     } catch (...) {
3178       {
3179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3180       };
3181     }
3182   }
3183
3184   jresult = (void *)result;
3185   return jresult;
3186 }
3187
3188
3189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3190   uintp *arg1 = (uintp *) 0 ;
3191
3192   arg1 = (uintp *)jarg1;
3193   {
3194     try {
3195       delete_uintp(arg1);
3196     } catch (std::out_of_range& e) {
3197       {
3198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3199       };
3200     } catch (std::exception& e) {
3201       {
3202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3203       };
3204     } catch (Dali::DaliException e) {
3205       {
3206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3207       };
3208     } catch (...) {
3209       {
3210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3211       };
3212     }
3213   }
3214
3215 }
3216
3217
3218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3219   uintp *arg1 = (uintp *) 0 ;
3220   unsigned int arg2 ;
3221
3222   arg1 = (uintp *)jarg1;
3223   arg2 = (unsigned int)jarg2;
3224   {
3225     try {
3226       uintp_assign(arg1,arg2);
3227     } catch (std::out_of_range& e) {
3228       {
3229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3230       };
3231     } catch (std::exception& e) {
3232       {
3233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3234       };
3235     } catch (Dali::DaliException e) {
3236       {
3237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3238       };
3239     } catch (...) {
3240       {
3241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3242       };
3243     }
3244   }
3245
3246 }
3247
3248
3249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3250   unsigned int jresult ;
3251   uintp *arg1 = (uintp *) 0 ;
3252   unsigned int result;
3253
3254   arg1 = (uintp *)jarg1;
3255   {
3256     try {
3257       result = (unsigned int)uintp_value(arg1);
3258     } catch (std::out_of_range& e) {
3259       {
3260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3261       };
3262     } catch (std::exception& e) {
3263       {
3264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3265       };
3266     } catch (Dali::DaliException e) {
3267       {
3268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3269       };
3270     } catch (...) {
3271       {
3272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3273       };
3274     }
3275   }
3276
3277   jresult = result;
3278   return jresult;
3279 }
3280
3281
3282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3283   void * jresult ;
3284   uintp *arg1 = (uintp *) 0 ;
3285   unsigned int *result = 0 ;
3286
3287   arg1 = (uintp *)jarg1;
3288   {
3289     try {
3290       result = (unsigned int *)uintp_cast(arg1);
3291     } catch (std::out_of_range& e) {
3292       {
3293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3294       };
3295     } catch (std::exception& e) {
3296       {
3297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3298       };
3299     } catch (Dali::DaliException e) {
3300       {
3301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3302       };
3303     } catch (...) {
3304       {
3305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3306       };
3307     }
3308   }
3309
3310   jresult = (void *)result;
3311   return jresult;
3312 }
3313
3314
3315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3316   void * jresult ;
3317   unsigned int *arg1 = (unsigned int *) 0 ;
3318   uintp *result = 0 ;
3319
3320   arg1 = (unsigned int *)jarg1;
3321   {
3322     try {
3323       result = (uintp *)uintp_frompointer(arg1);
3324     } catch (std::out_of_range& e) {
3325       {
3326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3327       };
3328     } catch (std::exception& e) {
3329       {
3330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3331       };
3332     } catch (Dali::DaliException e) {
3333       {
3334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3335       };
3336     } catch (...) {
3337       {
3338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3339       };
3340     }
3341   }
3342
3343   jresult = (void *)result;
3344   return jresult;
3345 }
3346
3347
3348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3349   void * jresult ;
3350   ushortp *result = 0 ;
3351
3352   {
3353     try {
3354       result = (ushortp *)new_ushortp();
3355     } catch (std::out_of_range& e) {
3356       {
3357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3358       };
3359     } catch (std::exception& e) {
3360       {
3361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3362       };
3363     } catch (Dali::DaliException e) {
3364       {
3365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3366       };
3367     } catch (...) {
3368       {
3369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3370       };
3371     }
3372   }
3373
3374   jresult = (void *)result;
3375   return jresult;
3376 }
3377
3378
3379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3380   ushortp *arg1 = (ushortp *) 0 ;
3381
3382   arg1 = (ushortp *)jarg1;
3383   {
3384     try {
3385       delete_ushortp(arg1);
3386     } catch (std::out_of_range& e) {
3387       {
3388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3389       };
3390     } catch (std::exception& e) {
3391       {
3392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3393       };
3394     } catch (Dali::DaliException e) {
3395       {
3396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3397       };
3398     } catch (...) {
3399       {
3400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3401       };
3402     }
3403   }
3404
3405 }
3406
3407
3408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3409   ushortp *arg1 = (ushortp *) 0 ;
3410   unsigned short arg2 ;
3411
3412   arg1 = (ushortp *)jarg1;
3413   arg2 = (unsigned short)jarg2;
3414   {
3415     try {
3416       ushortp_assign(arg1,arg2);
3417     } catch (std::out_of_range& e) {
3418       {
3419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3420       };
3421     } catch (std::exception& e) {
3422       {
3423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3424       };
3425     } catch (Dali::DaliException e) {
3426       {
3427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3428       };
3429     } catch (...) {
3430       {
3431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3432       };
3433     }
3434   }
3435
3436 }
3437
3438
3439 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3440   unsigned short jresult ;
3441   ushortp *arg1 = (ushortp *) 0 ;
3442   unsigned short result;
3443
3444   arg1 = (ushortp *)jarg1;
3445   {
3446     try {
3447       result = (unsigned short)ushortp_value(arg1);
3448     } catch (std::out_of_range& e) {
3449       {
3450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3451       };
3452     } catch (std::exception& e) {
3453       {
3454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3455       };
3456     } catch (Dali::DaliException e) {
3457       {
3458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3459       };
3460     } catch (...) {
3461       {
3462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3463       };
3464     }
3465   }
3466
3467   jresult = result;
3468   return jresult;
3469 }
3470
3471
3472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3473   void * jresult ;
3474   ushortp *arg1 = (ushortp *) 0 ;
3475   unsigned short *result = 0 ;
3476
3477   arg1 = (ushortp *)jarg1;
3478   {
3479     try {
3480       result = (unsigned short *)ushortp_cast(arg1);
3481     } catch (std::out_of_range& e) {
3482       {
3483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3484       };
3485     } catch (std::exception& e) {
3486       {
3487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3488       };
3489     } catch (Dali::DaliException e) {
3490       {
3491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3492       };
3493     } catch (...) {
3494       {
3495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3496       };
3497     }
3498   }
3499
3500   jresult = (void *)result;
3501   return jresult;
3502 }
3503
3504
3505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3506   void * jresult ;
3507   unsigned short *arg1 = (unsigned short *) 0 ;
3508   ushortp *result = 0 ;
3509
3510   arg1 = (unsigned short *)jarg1;
3511   {
3512     try {
3513       result = (ushortp *)ushortp_frompointer(arg1);
3514     } catch (std::out_of_range& e) {
3515       {
3516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3517       };
3518     } catch (std::exception& e) {
3519       {
3520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3521       };
3522     } catch (Dali::DaliException e) {
3523       {
3524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3525       };
3526     } catch (...) {
3527       {
3528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3529       };
3530     }
3531   }
3532
3533   jresult = (void *)result;
3534   return jresult;
3535 }
3536
3537
3538 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3539   unsigned int jresult ;
3540   int arg1 ;
3541   unsigned int result;
3542
3543   arg1 = (int)jarg1;
3544   {
3545     try {
3546       result = (unsigned int)int_to_uint(arg1);
3547     } catch (std::out_of_range& e) {
3548       {
3549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3550       };
3551     } catch (std::exception& e) {
3552       {
3553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3554       };
3555     } catch (Dali::DaliException e) {
3556       {
3557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3558       };
3559     } catch (...) {
3560       {
3561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3562       };
3563     }
3564   }
3565
3566   jresult = result;
3567   return jresult;
3568 }
3569
3570
3571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3572   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3573
3574   arg1 = (Dali::RefObject *)jarg1;
3575   {
3576     try {
3577       (arg1)->Reference();
3578     } catch (std::out_of_range& e) {
3579       {
3580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3581       };
3582     } catch (std::exception& e) {
3583       {
3584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3585       };
3586     } catch (Dali::DaliException e) {
3587       {
3588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3589       };
3590     } catch (...) {
3591       {
3592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3593       };
3594     }
3595   }
3596
3597 }
3598
3599
3600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3601   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3602
3603   arg1 = (Dali::RefObject *)jarg1;
3604   {
3605     try {
3606       (arg1)->Unreference();
3607     } catch (std::out_of_range& e) {
3608       {
3609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3610       };
3611     } catch (std::exception& e) {
3612       {
3613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3614       };
3615     } catch (Dali::DaliException e) {
3616       {
3617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3618       };
3619     } catch (...) {
3620       {
3621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3622       };
3623     }
3624   }
3625
3626 }
3627
3628
3629 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3630   int jresult ;
3631   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3632   int result;
3633
3634   arg1 = (Dali::RefObject *)jarg1;
3635   {
3636     try {
3637       result = (int)(arg1)->ReferenceCount();
3638     } catch (std::out_of_range& e) {
3639       {
3640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3641       };
3642     } catch (std::exception& e) {
3643       {
3644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3645       };
3646     } catch (Dali::DaliException e) {
3647       {
3648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3649       };
3650     } catch (...) {
3651       {
3652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3653       };
3654     }
3655   }
3656
3657   jresult = result;
3658   return jresult;
3659 }
3660
3661
3662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3663   void * jresult ;
3664   Dali::Any *result = 0 ;
3665
3666   {
3667     try {
3668       result = (Dali::Any *)new Dali::Any();
3669     } catch (std::out_of_range& e) {
3670       {
3671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3672       };
3673     } catch (std::exception& e) {
3674       {
3675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3676       };
3677     } catch (Dali::DaliException e) {
3678       {
3679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3680       };
3681     } catch (...) {
3682       {
3683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3684       };
3685     }
3686   }
3687
3688   jresult = (void *)result;
3689   return jresult;
3690 }
3691
3692
3693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3694   Dali::Any *arg1 = (Dali::Any *) 0 ;
3695
3696   arg1 = (Dali::Any *)jarg1;
3697   {
3698     try {
3699       delete arg1;
3700     } catch (std::out_of_range& e) {
3701       {
3702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3703       };
3704     } catch (std::exception& e) {
3705       {
3706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3707       };
3708     } catch (Dali::DaliException e) {
3709       {
3710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3711       };
3712     } catch (...) {
3713       {
3714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3715       };
3716     }
3717   }
3718
3719 }
3720
3721
3722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3723   char *arg1 = (char *) 0 ;
3724
3725   arg1 = (char *)jarg1;
3726   {
3727     try {
3728       Dali::Any::AssertAlways((char const *)arg1);
3729     } catch (std::out_of_range& e) {
3730       {
3731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3732       };
3733     } catch (std::exception& e) {
3734       {
3735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3736       };
3737     } catch (Dali::DaliException e) {
3738       {
3739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3740       };
3741     } catch (...) {
3742       {
3743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3744       };
3745     }
3746   }
3747
3748 }
3749
3750
3751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3752   void * jresult ;
3753   Dali::Any *arg1 = 0 ;
3754   Dali::Any *result = 0 ;
3755
3756   arg1 = (Dali::Any *)jarg1;
3757   if (!arg1) {
3758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3759     return 0;
3760   }
3761   {
3762     try {
3763       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3764     } catch (std::out_of_range& e) {
3765       {
3766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3767       };
3768     } catch (std::exception& e) {
3769       {
3770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3771       };
3772     } catch (Dali::DaliException e) {
3773       {
3774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3775       };
3776     } catch (...) {
3777       {
3778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3779       };
3780     }
3781   }
3782
3783   jresult = (void *)result;
3784   return jresult;
3785 }
3786
3787
3788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3789   void * jresult ;
3790   Dali::Any *arg1 = (Dali::Any *) 0 ;
3791   Dali::Any *arg2 = 0 ;
3792   Dali::Any *result = 0 ;
3793
3794   arg1 = (Dali::Any *)jarg1;
3795   arg2 = (Dali::Any *)jarg2;
3796   if (!arg2) {
3797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3798     return 0;
3799   }
3800   {
3801     try {
3802       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3803     } catch (std::out_of_range& e) {
3804       {
3805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3806       };
3807     } catch (std::exception& e) {
3808       {
3809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3810       };
3811     } catch (Dali::DaliException e) {
3812       {
3813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3814       };
3815     } catch (...) {
3816       {
3817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3818       };
3819     }
3820   }
3821
3822   jresult = (void *)result;
3823   return jresult;
3824 }
3825
3826
3827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3828   void * jresult ;
3829   Dali::Any *arg1 = (Dali::Any *) 0 ;
3830   std::type_info *result = 0 ;
3831
3832   arg1 = (Dali::Any *)jarg1;
3833   {
3834     try {
3835       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3836     } catch (std::out_of_range& e) {
3837       {
3838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3839       };
3840     } catch (std::exception& e) {
3841       {
3842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3843       };
3844     } catch (Dali::DaliException e) {
3845       {
3846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3847       };
3848     } catch (...) {
3849       {
3850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3851       };
3852     }
3853   }
3854
3855   jresult = (void *)result;
3856   return jresult;
3857 }
3858
3859
3860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3861   unsigned int jresult ;
3862   Dali::Any *arg1 = (Dali::Any *) 0 ;
3863   bool result;
3864
3865   arg1 = (Dali::Any *)jarg1;
3866   {
3867     try {
3868       result = (bool)((Dali::Any const *)arg1)->Empty();
3869     } catch (std::out_of_range& e) {
3870       {
3871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3872       };
3873     } catch (std::exception& e) {
3874       {
3875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3876       };
3877     } catch (Dali::DaliException e) {
3878       {
3879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3880       };
3881     } catch (...) {
3882       {
3883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3884       };
3885     }
3886   }
3887
3888   jresult = result;
3889   return jresult;
3890 }
3891
3892
3893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3894   void * jresult ;
3895   std::type_info *arg1 = 0 ;
3896   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3897   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3898   Dali::Any::AnyContainerBase *result = 0 ;
3899
3900   arg1 = (std::type_info *)jarg1;
3901   if (!arg1) {
3902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3903     return 0;
3904   }
3905   arg2 = (Dali::Any::CloneFunc)jarg2;
3906   arg3 = (Dali::Any::DeleteFunc)jarg3;
3907   {
3908     try {
3909       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3910     } catch (std::out_of_range& e) {
3911       {
3912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3913       };
3914     } catch (std::exception& e) {
3915       {
3916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3917       };
3918     } catch (Dali::DaliException e) {
3919       {
3920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3921       };
3922     } catch (...) {
3923       {
3924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3925       };
3926     }
3927   }
3928
3929   jresult = (void *)result;
3930   return jresult;
3931 }
3932
3933
3934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3935   void * jresult ;
3936   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3937   std::type_info *result = 0 ;
3938
3939   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3940   {
3941     try {
3942       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3943     } catch (std::out_of_range& e) {
3944       {
3945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3946       };
3947     } catch (std::exception& e) {
3948       {
3949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3950       };
3951     } catch (Dali::DaliException e) {
3952       {
3953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3954       };
3955     } catch (...) {
3956       {
3957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3958       };
3959     }
3960   }
3961
3962   jresult = (void *)result;
3963   return jresult;
3964 }
3965
3966
3967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3968   void * jresult ;
3969   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3970   ::std::type_info *result = 0 ;
3971
3972   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3973   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3974   jresult = (void *)result;
3975   return jresult;
3976 }
3977
3978
3979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3980   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3981   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3982
3983   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3984   arg2 = (Dali::Any::CloneFunc)jarg2;
3985   if (arg1) (arg1)->mCloneFunc = arg2;
3986 }
3987
3988
3989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3990   void * jresult ;
3991   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3992   Dali::Any::CloneFunc result;
3993
3994   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3995   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3996   jresult = (void *)result;
3997   return jresult;
3998 }
3999
4000
4001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4002   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4003   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4004
4005   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4006   arg2 = (Dali::Any::DeleteFunc)jarg2;
4007   if (arg1) (arg1)->mDeleteFunc = arg2;
4008 }
4009
4010
4011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4012   void * jresult ;
4013   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4014   Dali::Any::DeleteFunc result;
4015
4016   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4017   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4018   jresult = (void *)result;
4019   return jresult;
4020 }
4021
4022
4023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4024   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4025
4026   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4027   {
4028     try {
4029       delete arg1;
4030     } catch (std::out_of_range& e) {
4031       {
4032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4033       };
4034     } catch (std::exception& e) {
4035       {
4036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4037       };
4038     } catch (Dali::DaliException e) {
4039       {
4040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4041       };
4042     } catch (...) {
4043       {
4044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4045       };
4046     }
4047   }
4048
4049 }
4050
4051
4052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4053   Dali::Any *arg1 = (Dali::Any *) 0 ;
4054   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4055
4056   arg1 = (Dali::Any *)jarg1;
4057   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4058   if (arg1) (arg1)->mContainer = arg2;
4059 }
4060
4061
4062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4063   void * jresult ;
4064   Dali::Any *arg1 = (Dali::Any *) 0 ;
4065   Dali::Any::AnyContainerBase *result = 0 ;
4066
4067   arg1 = (Dali::Any *)jarg1;
4068   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4069   jresult = (void *)result;
4070   return jresult;
4071 }
4072
4073
4074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4075   char *arg1 = (char *) 0 ;
4076   char *arg2 = (char *) 0 ;
4077
4078   arg1 = (char *)jarg1;
4079   arg2 = (char *)jarg2;
4080   {
4081     try {
4082       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4083     } catch (std::out_of_range& e) {
4084       {
4085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4086       };
4087     } catch (std::exception& e) {
4088       {
4089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4090       };
4091     } catch (Dali::DaliException e) {
4092       {
4093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4094       };
4095     } catch (...) {
4096       {
4097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4098       };
4099     }
4100   }
4101
4102 }
4103
4104
4105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4106   void * jresult ;
4107   char *arg1 = (char *) 0 ;
4108   char *arg2 = (char *) 0 ;
4109   Dali::DaliException *result = 0 ;
4110
4111   arg1 = (char *)jarg1;
4112   arg2 = (char *)jarg2;
4113   {
4114     try {
4115       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4116     } catch (std::out_of_range& e) {
4117       {
4118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4119       };
4120     } catch (std::exception& e) {
4121       {
4122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4123       };
4124     } catch (Dali::DaliException e) {
4125       {
4126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4127       };
4128     } catch (...) {
4129       {
4130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4131       };
4132     }
4133   }
4134
4135   jresult = (void *)result;
4136   return jresult;
4137 }
4138
4139
4140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4141   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4142   std::string arg2 = std::string(jarg2);
4143
4144   arg1 = (Dali::DaliException *)jarg1;
4145   {
4146     if (!arg2.empty()) {
4147       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4148     } else {
4149       arg1->location = 0;
4150     }
4151   }
4152 }
4153
4154 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4155   char * jresult ;
4156   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4157   char *result = 0 ;
4158
4159   arg1 = (Dali::DaliException *)jarg1;
4160   result = (char *) ((arg1)->location);
4161   jresult = SWIG_csharp_string_callback((const char *)result);
4162   return jresult;
4163 }
4164
4165
4166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4167   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4168   std::string arg2 = std::string(jarg2);
4169
4170   arg1 = (Dali::DaliException *)jarg1;
4171   {
4172     if (!arg2.empty()) {
4173       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4174     } else {
4175       arg1->condition = 0;
4176     }
4177   }
4178 }
4179
4180
4181 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4182   char * jresult ;
4183   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4184   char *result = 0 ;
4185
4186   arg1 = (Dali::DaliException *)jarg1;
4187   result = (char *) ((arg1)->condition);
4188   jresult = SWIG_csharp_string_callback((const char *)result);
4189   return jresult;
4190 }
4191
4192
4193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4194   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4195
4196   arg1 = (Dali::DaliException *)jarg1;
4197   {
4198     try {
4199       delete arg1;
4200     } catch (std::out_of_range& e) {
4201       {
4202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4203       };
4204     } catch (std::exception& e) {
4205       {
4206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4207       };
4208     } catch (Dali::DaliException e) {
4209       {
4210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4211       };
4212     } catch (...) {
4213       {
4214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4215       };
4216     }
4217   }
4218
4219 }
4220
4221
4222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4223   void * jresult ;
4224   Dali::Vector2 *result = 0 ;
4225
4226   {
4227     try {
4228       result = (Dali::Vector2 *)new Dali::Vector2();
4229     } catch (std::out_of_range& e) {
4230       {
4231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4232       };
4233     } catch (std::exception& e) {
4234       {
4235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4236       };
4237     } catch (Dali::DaliException e) {
4238       {
4239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4240       };
4241     } catch (...) {
4242       {
4243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4244       };
4245     }
4246   }
4247
4248   jresult = (void *)result;
4249   return jresult;
4250 }
4251
4252
4253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4254   void * jresult ;
4255   float arg1 ;
4256   float arg2 ;
4257   Dali::Vector2 *result = 0 ;
4258
4259   arg1 = (float)jarg1;
4260   arg2 = (float)jarg2;
4261   {
4262     try {
4263       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4264     } catch (std::out_of_range& e) {
4265       {
4266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4267       };
4268     } catch (std::exception& e) {
4269       {
4270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4271       };
4272     } catch (Dali::DaliException e) {
4273       {
4274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4275       };
4276     } catch (...) {
4277       {
4278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4279       };
4280     }
4281   }
4282
4283   jresult = (void *)result;
4284   return jresult;
4285 }
4286
4287
4288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4289   void * jresult ;
4290   float *arg1 = (float *) 0 ;
4291   Dali::Vector2 *result = 0 ;
4292
4293   arg1 = jarg1;
4294   {
4295     try {
4296       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4297     } catch (std::out_of_range& e) {
4298       {
4299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4300       };
4301     } catch (std::exception& e) {
4302       {
4303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4304       };
4305     } catch (Dali::DaliException e) {
4306       {
4307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4308       };
4309     } catch (...) {
4310       {
4311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4312       };
4313     }
4314   }
4315
4316   jresult = (void *)result;
4317
4318
4319   return jresult;
4320 }
4321
4322
4323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4324   void * jresult ;
4325   Dali::Vector3 *arg1 = 0 ;
4326   Dali::Vector2 *result = 0 ;
4327
4328   arg1 = (Dali::Vector3 *)jarg1;
4329   if (!arg1) {
4330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4331     return 0;
4332   }
4333   {
4334     try {
4335       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4336     } catch (std::out_of_range& e) {
4337       {
4338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4339       };
4340     } catch (std::exception& e) {
4341       {
4342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4343       };
4344     } catch (Dali::DaliException e) {
4345       {
4346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4347       };
4348     } catch (...) {
4349       {
4350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4351       };
4352     }
4353   }
4354
4355   jresult = (void *)result;
4356   return jresult;
4357 }
4358
4359
4360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4361   void * jresult ;
4362   Dali::Vector4 *arg1 = 0 ;
4363   Dali::Vector2 *result = 0 ;
4364
4365   arg1 = (Dali::Vector4 *)jarg1;
4366   if (!arg1) {
4367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4368     return 0;
4369   }
4370   {
4371     try {
4372       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4373     } catch (std::out_of_range& e) {
4374       {
4375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4376       };
4377     } catch (std::exception& e) {
4378       {
4379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4380       };
4381     } catch (Dali::DaliException e) {
4382       {
4383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4384       };
4385     } catch (...) {
4386       {
4387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4388       };
4389     }
4390   }
4391
4392   jresult = (void *)result;
4393   return jresult;
4394 }
4395
4396
4397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4398   void * jresult ;
4399   Dali::Vector2 *result = 0 ;
4400
4401   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4402   jresult = (void *)result;
4403   return jresult;
4404 }
4405
4406
4407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4408   void * jresult ;
4409   Dali::Vector2 *result = 0 ;
4410
4411   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4412   jresult = (void *)result;
4413   return jresult;
4414 }
4415
4416
4417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4418   void * jresult ;
4419   Dali::Vector2 *result = 0 ;
4420
4421   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4422   jresult = (void *)result;
4423   return jresult;
4424 }
4425
4426
4427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4428   void * jresult ;
4429   Dali::Vector2 *result = 0 ;
4430
4431   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4432   jresult = (void *)result;
4433   return jresult;
4434 }
4435
4436
4437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4438   void * jresult ;
4439   Dali::Vector2 *result = 0 ;
4440
4441   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4442   jresult = (void *)result;
4443   return jresult;
4444 }
4445
4446
4447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4448   void * jresult ;
4449   Dali::Vector2 *result = 0 ;
4450
4451   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4452   jresult = (void *)result;
4453   return jresult;
4454 }
4455
4456
4457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4458   void * jresult ;
4459   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4460   float *arg2 = (float *) 0 ;
4461   Dali::Vector2 *result = 0 ;
4462
4463   arg1 = (Dali::Vector2 *)jarg1;
4464   arg2 = jarg2;
4465   {
4466     try {
4467       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4468     } catch (std::out_of_range& e) {
4469       {
4470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4471       };
4472     } catch (std::exception& e) {
4473       {
4474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4475       };
4476     } catch (Dali::DaliException e) {
4477       {
4478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4479       };
4480     } catch (...) {
4481       {
4482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4483       };
4484     }
4485   }
4486
4487   jresult = (void *)result;
4488
4489
4490   return jresult;
4491 }
4492
4493
4494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4495   void * jresult ;
4496   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4497   Dali::Vector3 *arg2 = 0 ;
4498   Dali::Vector2 *result = 0 ;
4499
4500   arg1 = (Dali::Vector2 *)jarg1;
4501   arg2 = (Dali::Vector3 *)jarg2;
4502   if (!arg2) {
4503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4504     return 0;
4505   }
4506   {
4507     try {
4508       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4509     } catch (std::out_of_range& e) {
4510       {
4511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4512       };
4513     } catch (std::exception& e) {
4514       {
4515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4516       };
4517     } catch (Dali::DaliException e) {
4518       {
4519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4520       };
4521     } catch (...) {
4522       {
4523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4524       };
4525     }
4526   }
4527
4528   jresult = (void *)result;
4529   return jresult;
4530 }
4531
4532
4533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4534   void * jresult ;
4535   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4536   Dali::Vector4 *arg2 = 0 ;
4537   Dali::Vector2 *result = 0 ;
4538
4539   arg1 = (Dali::Vector2 *)jarg1;
4540   arg2 = (Dali::Vector4 *)jarg2;
4541   if (!arg2) {
4542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4543     return 0;
4544   }
4545   {
4546     try {
4547       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4548     } catch (std::out_of_range& e) {
4549       {
4550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4551       };
4552     } catch (std::exception& e) {
4553       {
4554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4555       };
4556     } catch (Dali::DaliException e) {
4557       {
4558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4559       };
4560     } catch (...) {
4561       {
4562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4563       };
4564     }
4565   }
4566
4567   jresult = (void *)result;
4568   return jresult;
4569 }
4570
4571
4572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4573   void * jresult ;
4574   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4575   Dali::Vector2 *arg2 = 0 ;
4576   Dali::Vector2 result;
4577
4578   arg1 = (Dali::Vector2 *)jarg1;
4579   arg2 = (Dali::Vector2 *)jarg2;
4580   if (!arg2) {
4581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4582     return 0;
4583   }
4584   {
4585     try {
4586       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4587     } catch (std::out_of_range& e) {
4588       {
4589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4590       };
4591     } catch (std::exception& e) {
4592       {
4593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4594       };
4595     } catch (Dali::DaliException e) {
4596       {
4597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4598       };
4599     } catch (...) {
4600       {
4601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4602       };
4603     }
4604   }
4605
4606   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4607   return jresult;
4608 }
4609
4610
4611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4612   void * jresult ;
4613   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4614   Dali::Vector2 *arg2 = 0 ;
4615   Dali::Vector2 *result = 0 ;
4616
4617   arg1 = (Dali::Vector2 *)jarg1;
4618   arg2 = (Dali::Vector2 *)jarg2;
4619   if (!arg2) {
4620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4621     return 0;
4622   }
4623   {
4624     try {
4625       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4626     } catch (std::out_of_range& e) {
4627       {
4628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4629       };
4630     } catch (std::exception& e) {
4631       {
4632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4633       };
4634     } catch (Dali::DaliException e) {
4635       {
4636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4637       };
4638     } catch (...) {
4639       {
4640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4641       };
4642     }
4643   }
4644
4645   jresult = (void *)result;
4646   return jresult;
4647 }
4648
4649
4650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4651   void * jresult ;
4652   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4653   Dali::Vector2 *arg2 = 0 ;
4654   Dali::Vector2 result;
4655
4656   arg1 = (Dali::Vector2 *)jarg1;
4657   arg2 = (Dali::Vector2 *)jarg2;
4658   if (!arg2) {
4659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4660     return 0;
4661   }
4662   {
4663     try {
4664       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4665     } catch (std::out_of_range& e) {
4666       {
4667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4668       };
4669     } catch (std::exception& e) {
4670       {
4671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4672       };
4673     } catch (Dali::DaliException e) {
4674       {
4675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4676       };
4677     } catch (...) {
4678       {
4679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4680       };
4681     }
4682   }
4683
4684   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4685   return jresult;
4686 }
4687
4688
4689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4690   void * jresult ;
4691   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4692   Dali::Vector2 *arg2 = 0 ;
4693   Dali::Vector2 *result = 0 ;
4694
4695   arg1 = (Dali::Vector2 *)jarg1;
4696   arg2 = (Dali::Vector2 *)jarg2;
4697   if (!arg2) {
4698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4699     return 0;
4700   }
4701   {
4702     try {
4703       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4704     } catch (std::out_of_range& e) {
4705       {
4706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4707       };
4708     } catch (std::exception& e) {
4709       {
4710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4711       };
4712     } catch (Dali::DaliException e) {
4713       {
4714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4715       };
4716     } catch (...) {
4717       {
4718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4719       };
4720     }
4721   }
4722
4723   jresult = (void *)result;
4724   return jresult;
4725 }
4726
4727
4728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4729   void * jresult ;
4730   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4731   Dali::Vector2 *arg2 = 0 ;
4732   Dali::Vector2 result;
4733
4734   arg1 = (Dali::Vector2 *)jarg1;
4735   arg2 = (Dali::Vector2 *)jarg2;
4736   if (!arg2) {
4737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4738     return 0;
4739   }
4740   {
4741     try {
4742       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4743     } catch (std::out_of_range& e) {
4744       {
4745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4746       };
4747     } catch (std::exception& e) {
4748       {
4749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4750       };
4751     } catch (Dali::DaliException e) {
4752       {
4753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4754       };
4755     } catch (...) {
4756       {
4757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4758       };
4759     }
4760   }
4761
4762   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4763   return jresult;
4764 }
4765
4766
4767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4768   void * jresult ;
4769   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4770   float arg2 ;
4771   Dali::Vector2 result;
4772
4773   arg1 = (Dali::Vector2 *)jarg1;
4774   arg2 = (float)jarg2;
4775   {
4776     try {
4777       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4778     } catch (std::out_of_range& e) {
4779       {
4780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4781       };
4782     } catch (std::exception& e) {
4783       {
4784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4785       };
4786     } catch (Dali::DaliException e) {
4787       {
4788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4789       };
4790     } catch (...) {
4791       {
4792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4793       };
4794     }
4795   }
4796
4797   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4798   return jresult;
4799 }
4800
4801
4802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4803   void * jresult ;
4804   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4805   Dali::Vector2 *arg2 = 0 ;
4806   Dali::Vector2 *result = 0 ;
4807
4808   arg1 = (Dali::Vector2 *)jarg1;
4809   arg2 = (Dali::Vector2 *)jarg2;
4810   if (!arg2) {
4811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4812     return 0;
4813   }
4814   {
4815     try {
4816       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4817     } catch (std::out_of_range& e) {
4818       {
4819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4820       };
4821     } catch (std::exception& e) {
4822       {
4823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4824       };
4825     } catch (Dali::DaliException e) {
4826       {
4827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4828       };
4829     } catch (...) {
4830       {
4831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4832       };
4833     }
4834   }
4835
4836   jresult = (void *)result;
4837   return jresult;
4838 }
4839
4840
4841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4842   void * jresult ;
4843   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4844   float arg2 ;
4845   Dali::Vector2 *result = 0 ;
4846
4847   arg1 = (Dali::Vector2 *)jarg1;
4848   arg2 = (float)jarg2;
4849   {
4850     try {
4851       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4852     } catch (std::out_of_range& e) {
4853       {
4854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4855       };
4856     } catch (std::exception& e) {
4857       {
4858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4859       };
4860     } catch (Dali::DaliException e) {
4861       {
4862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4863       };
4864     } catch (...) {
4865       {
4866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4867       };
4868     }
4869   }
4870
4871   jresult = (void *)result;
4872   return jresult;
4873 }
4874
4875
4876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4877   void * jresult ;
4878   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4879   Dali::Vector2 *arg2 = 0 ;
4880   Dali::Vector2 result;
4881
4882   arg1 = (Dali::Vector2 *)jarg1;
4883   arg2 = (Dali::Vector2 *)jarg2;
4884   if (!arg2) {
4885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4886     return 0;
4887   }
4888   {
4889     try {
4890       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4891     } catch (std::out_of_range& e) {
4892       {
4893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4894       };
4895     } catch (std::exception& e) {
4896       {
4897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4898       };
4899     } catch (Dali::DaliException e) {
4900       {
4901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4902       };
4903     } catch (...) {
4904       {
4905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4906       };
4907     }
4908   }
4909
4910   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4911   return jresult;
4912 }
4913
4914
4915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4916   void * jresult ;
4917   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4918   float arg2 ;
4919   Dali::Vector2 result;
4920
4921   arg1 = (Dali::Vector2 *)jarg1;
4922   arg2 = (float)jarg2;
4923   {
4924     try {
4925       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4926     } catch (std::out_of_range& e) {
4927       {
4928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4929       };
4930     } catch (std::exception& e) {
4931       {
4932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4933       };
4934     } catch (Dali::DaliException e) {
4935       {
4936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4937       };
4938     } catch (...) {
4939       {
4940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4941       };
4942     }
4943   }
4944
4945   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4946   return jresult;
4947 }
4948
4949
4950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4951   void * jresult ;
4952   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4953   Dali::Vector2 *arg2 = 0 ;
4954   Dali::Vector2 *result = 0 ;
4955
4956   arg1 = (Dali::Vector2 *)jarg1;
4957   arg2 = (Dali::Vector2 *)jarg2;
4958   if (!arg2) {
4959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4960     return 0;
4961   }
4962   {
4963     try {
4964       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4965     } catch (std::out_of_range& e) {
4966       {
4967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4968       };
4969     } catch (std::exception& e) {
4970       {
4971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4972       };
4973     } catch (Dali::DaliException e) {
4974       {
4975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4976       };
4977     } catch (...) {
4978       {
4979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4980       };
4981     }
4982   }
4983
4984   jresult = (void *)result;
4985   return jresult;
4986 }
4987
4988
4989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4990   void * jresult ;
4991   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4992   float arg2 ;
4993   Dali::Vector2 *result = 0 ;
4994
4995   arg1 = (Dali::Vector2 *)jarg1;
4996   arg2 = (float)jarg2;
4997   {
4998     try {
4999       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5000     } catch (std::out_of_range& e) {
5001       {
5002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5003       };
5004     } catch (std::exception& e) {
5005       {
5006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5007       };
5008     } catch (Dali::DaliException e) {
5009       {
5010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5011       };
5012     } catch (...) {
5013       {
5014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5015       };
5016     }
5017   }
5018
5019   jresult = (void *)result;
5020   return jresult;
5021 }
5022
5023
5024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5025   void * jresult ;
5026   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5027   Dali::Vector2 result;
5028
5029   arg1 = (Dali::Vector2 *)jarg1;
5030   {
5031     try {
5032       result = ((Dali::Vector2 const *)arg1)->operator -();
5033     } catch (std::out_of_range& e) {
5034       {
5035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5036       };
5037     } catch (std::exception& e) {
5038       {
5039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5040       };
5041     } catch (Dali::DaliException e) {
5042       {
5043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5044       };
5045     } catch (...) {
5046       {
5047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5048       };
5049     }
5050   }
5051
5052   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5053   return jresult;
5054 }
5055
5056
5057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5058   unsigned int jresult ;
5059   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5060   Dali::Vector2 *arg2 = 0 ;
5061   bool result;
5062
5063   arg1 = (Dali::Vector2 *)jarg1;
5064   arg2 = (Dali::Vector2 *)jarg2;
5065   if (!arg2) {
5066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5067     return 0;
5068   }
5069   {
5070     try {
5071       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5072     } catch (std::out_of_range& e) {
5073       {
5074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5075       };
5076     } catch (std::exception& e) {
5077       {
5078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5079       };
5080     } catch (Dali::DaliException e) {
5081       {
5082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5083       };
5084     } catch (...) {
5085       {
5086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5087       };
5088     }
5089   }
5090
5091   jresult = result;
5092   return jresult;
5093 }
5094
5095
5096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5097   unsigned int jresult ;
5098   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5099   Dali::Vector2 *arg2 = 0 ;
5100   bool result;
5101
5102   arg1 = (Dali::Vector2 *)jarg1;
5103   arg2 = (Dali::Vector2 *)jarg2;
5104   if (!arg2) {
5105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5106     return 0;
5107   }
5108   {
5109     try {
5110       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5111     } catch (std::out_of_range& e) {
5112       {
5113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5114       };
5115     } catch (std::exception& e) {
5116       {
5117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5118       };
5119     } catch (Dali::DaliException e) {
5120       {
5121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5122       };
5123     } catch (...) {
5124       {
5125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5126       };
5127     }
5128   }
5129
5130   jresult = result;
5131   return jresult;
5132 }
5133
5134
5135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5136   float jresult ;
5137   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5138   unsigned int arg2 ;
5139   float *result = 0 ;
5140
5141   arg1 = (Dali::Vector2 *)jarg1;
5142   arg2 = (unsigned int)jarg2;
5143   {
5144     try {
5145       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5146     } catch (std::out_of_range& e) {
5147       {
5148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5149       };
5150     } catch (std::exception& e) {
5151       {
5152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5153       };
5154     } catch (Dali::DaliException e) {
5155       {
5156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5157       };
5158     } catch (...) {
5159       {
5160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5161       };
5162     }
5163   }
5164
5165   jresult = *result;
5166   return jresult;
5167 }
5168
5169
5170 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5171   float jresult ;
5172   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5173   float result;
5174
5175   arg1 = (Dali::Vector2 *)jarg1;
5176   {
5177     try {
5178       result = (float)((Dali::Vector2 const *)arg1)->Length();
5179     } catch (std::out_of_range& e) {
5180       {
5181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5182       };
5183     } catch (std::exception& e) {
5184       {
5185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5186       };
5187     } catch (Dali::DaliException e) {
5188       {
5189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5190       };
5191     } catch (...) {
5192       {
5193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5194       };
5195     }
5196   }
5197
5198   jresult = result;
5199   return jresult;
5200 }
5201
5202
5203 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5204   float jresult ;
5205   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5206   float result;
5207
5208   arg1 = (Dali::Vector2 *)jarg1;
5209   {
5210     try {
5211       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5212     } catch (std::out_of_range& e) {
5213       {
5214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5215       };
5216     } catch (std::exception& e) {
5217       {
5218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5219       };
5220     } catch (Dali::DaliException e) {
5221       {
5222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5223       };
5224     } catch (...) {
5225       {
5226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5227       };
5228     }
5229   }
5230
5231   jresult = result;
5232   return jresult;
5233 }
5234
5235
5236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5237   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5238
5239   arg1 = (Dali::Vector2 *)jarg1;
5240   {
5241     try {
5242       (arg1)->Normalize();
5243     } catch (std::out_of_range& e) {
5244       {
5245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5246       };
5247     } catch (std::exception& e) {
5248       {
5249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5250       };
5251     } catch (Dali::DaliException e) {
5252       {
5253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5254       };
5255     } catch (...) {
5256       {
5257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5258       };
5259     }
5260   }
5261
5262 }
5263
5264
5265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5266   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5267   Dali::Vector2 *arg2 = 0 ;
5268   Dali::Vector2 *arg3 = 0 ;
5269
5270   arg1 = (Dali::Vector2 *)jarg1;
5271   arg2 = (Dali::Vector2 *)jarg2;
5272   if (!arg2) {
5273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5274     return ;
5275   }
5276   arg3 = (Dali::Vector2 *)jarg3;
5277   if (!arg3) {
5278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5279     return ;
5280   }
5281   {
5282     try {
5283       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5284     } catch (std::out_of_range& e) {
5285       {
5286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5287       };
5288     } catch (std::exception& e) {
5289       {
5290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5291       };
5292     } catch (Dali::DaliException e) {
5293       {
5294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5295       };
5296     } catch (...) {
5297       {
5298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5299       };
5300     }
5301   }
5302
5303 }
5304
5305
5306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5307   void * jresult ;
5308   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5309   float *result = 0 ;
5310
5311   arg1 = (Dali::Vector2 *)jarg1;
5312   {
5313     try {
5314       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5315     } catch (std::out_of_range& e) {
5316       {
5317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5318       };
5319     } catch (std::exception& e) {
5320       {
5321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5322       };
5323     } catch (Dali::DaliException e) {
5324       {
5325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5326       };
5327     } catch (...) {
5328       {
5329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5330       };
5331     }
5332   }
5333
5334   jresult = (void *)result;
5335   return jresult;
5336 }
5337
5338
5339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5340   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5341   float arg2 ;
5342
5343   arg1 = (Dali::Vector2 *)jarg1;
5344   arg2 = (float)jarg2;
5345   if (arg1) (arg1)->x = arg2;
5346 }
5347
5348
5349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5350   float jresult ;
5351   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5352   float result;
5353
5354   arg1 = (Dali::Vector2 *)jarg1;
5355   result = (float) ((arg1)->x);
5356   jresult = result;
5357   return jresult;
5358 }
5359
5360
5361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5362   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5363   float arg2 ;
5364
5365   arg1 = (Dali::Vector2 *)jarg1;
5366   arg2 = (float)jarg2;
5367   if (arg1) (arg1)->width = arg2;
5368 }
5369
5370
5371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5372   float jresult ;
5373   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5374   float result;
5375
5376   arg1 = (Dali::Vector2 *)jarg1;
5377   result = (float) ((arg1)->width);
5378   jresult = result;
5379   return jresult;
5380 }
5381
5382
5383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5384   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5385   float arg2 ;
5386
5387   arg1 = (Dali::Vector2 *)jarg1;
5388   arg2 = (float)jarg2;
5389   if (arg1) (arg1)->y = arg2;
5390 }
5391
5392
5393 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5394   float jresult ;
5395   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5396   float result;
5397
5398   arg1 = (Dali::Vector2 *)jarg1;
5399   result = (float) ((arg1)->y);
5400   jresult = result;
5401   return jresult;
5402 }
5403
5404
5405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5406   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5407   float arg2 ;
5408
5409   arg1 = (Dali::Vector2 *)jarg1;
5410   arg2 = (float)jarg2;
5411   if (arg1) (arg1)->height = arg2;
5412 }
5413
5414
5415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5416   float jresult ;
5417   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5418   float result;
5419
5420   arg1 = (Dali::Vector2 *)jarg1;
5421   result = (float) ((arg1)->height);
5422   jresult = result;
5423   return jresult;
5424 }
5425
5426
5427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5428   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5429
5430   arg1 = (Dali::Vector2 *)jarg1;
5431   {
5432     try {
5433       delete arg1;
5434     } catch (std::out_of_range& e) {
5435       {
5436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5437       };
5438     } catch (std::exception& e) {
5439       {
5440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5441       };
5442     } catch (Dali::DaliException e) {
5443       {
5444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5445       };
5446     } catch (...) {
5447       {
5448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5449       };
5450     }
5451   }
5452
5453 }
5454
5455
5456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5457   void * jresult ;
5458   Dali::Vector2 *arg1 = 0 ;
5459   Dali::Vector2 *arg2 = 0 ;
5460   Dali::Vector2 result;
5461
5462   arg1 = (Dali::Vector2 *)jarg1;
5463   if (!arg1) {
5464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5465     return 0;
5466   }
5467   arg2 = (Dali::Vector2 *)jarg2;
5468   if (!arg2) {
5469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5470     return 0;
5471   }
5472   {
5473     try {
5474       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5475     } catch (std::out_of_range& e) {
5476       {
5477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5478       };
5479     } catch (std::exception& e) {
5480       {
5481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5482       };
5483     } catch (Dali::DaliException e) {
5484       {
5485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5486       };
5487     } catch (...) {
5488       {
5489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5490       };
5491     }
5492   }
5493
5494   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5495   return jresult;
5496 }
5497
5498
5499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5500   void * jresult ;
5501   Dali::Vector2 *arg1 = 0 ;
5502   Dali::Vector2 *arg2 = 0 ;
5503   Dali::Vector2 result;
5504
5505   arg1 = (Dali::Vector2 *)jarg1;
5506   if (!arg1) {
5507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5508     return 0;
5509   }
5510   arg2 = (Dali::Vector2 *)jarg2;
5511   if (!arg2) {
5512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5513     return 0;
5514   }
5515   {
5516     try {
5517       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5518     } catch (std::out_of_range& e) {
5519       {
5520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5521       };
5522     } catch (std::exception& e) {
5523       {
5524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5525       };
5526     } catch (Dali::DaliException e) {
5527       {
5528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5529       };
5530     } catch (...) {
5531       {
5532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5533       };
5534     }
5535   }
5536
5537   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5538   return jresult;
5539 }
5540
5541
5542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5543   void * jresult ;
5544   Dali::Vector2 *arg1 = 0 ;
5545   float *arg2 = 0 ;
5546   float *arg3 = 0 ;
5547   float temp2 ;
5548   float temp3 ;
5549   Dali::Vector2 result;
5550
5551   arg1 = (Dali::Vector2 *)jarg1;
5552   if (!arg1) {
5553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5554     return 0;
5555   }
5556   temp2 = (float)jarg2;
5557   arg2 = &temp2;
5558   temp3 = (float)jarg3;
5559   arg3 = &temp3;
5560   {
5561     try {
5562       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5563     } catch (std::out_of_range& e) {
5564       {
5565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5566       };
5567     } catch (std::exception& e) {
5568       {
5569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5570       };
5571     } catch (Dali::DaliException e) {
5572       {
5573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5574       };
5575     } catch (...) {
5576       {
5577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5578       };
5579     }
5580   }
5581
5582   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5583   return jresult;
5584 }
5585
5586
5587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5588   void * jresult ;
5589   Dali::Vector3 *result = 0 ;
5590
5591   {
5592     try {
5593       result = (Dali::Vector3 *)new Dali::Vector3();
5594     } catch (std::out_of_range& e) {
5595       {
5596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5597       };
5598     } catch (std::exception& e) {
5599       {
5600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5601       };
5602     } catch (Dali::DaliException e) {
5603       {
5604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5605       };
5606     } catch (...) {
5607       {
5608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5609       };
5610     }
5611   }
5612
5613   jresult = (void *)result;
5614   return jresult;
5615 }
5616
5617
5618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5619   void * jresult ;
5620   float arg1 ;
5621   float arg2 ;
5622   float arg3 ;
5623   Dali::Vector3 *result = 0 ;
5624
5625   arg1 = (float)jarg1;
5626   arg2 = (float)jarg2;
5627   arg3 = (float)jarg3;
5628   {
5629     try {
5630       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5631     } catch (std::out_of_range& e) {
5632       {
5633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5634       };
5635     } catch (std::exception& e) {
5636       {
5637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5638       };
5639     } catch (Dali::DaliException e) {
5640       {
5641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5642       };
5643     } catch (...) {
5644       {
5645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5646       };
5647     }
5648   }
5649
5650   jresult = (void *)result;
5651   return jresult;
5652 }
5653
5654
5655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5656   void * jresult ;
5657   float *arg1 = (float *) 0 ;
5658   Dali::Vector3 *result = 0 ;
5659
5660   arg1 = jarg1;
5661   {
5662     try {
5663       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5664     } catch (std::out_of_range& e) {
5665       {
5666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5667       };
5668     } catch (std::exception& e) {
5669       {
5670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5671       };
5672     } catch (Dali::DaliException e) {
5673       {
5674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5675       };
5676     } catch (...) {
5677       {
5678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5679       };
5680     }
5681   }
5682
5683   jresult = (void *)result;
5684
5685
5686   return jresult;
5687 }
5688
5689
5690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5691   void * jresult ;
5692   Dali::Vector2 *arg1 = 0 ;
5693   Dali::Vector3 *result = 0 ;
5694
5695   arg1 = (Dali::Vector2 *)jarg1;
5696   if (!arg1) {
5697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5698     return 0;
5699   }
5700   {
5701     try {
5702       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5703     } catch (std::out_of_range& e) {
5704       {
5705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5706       };
5707     } catch (std::exception& e) {
5708       {
5709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5710       };
5711     } catch (Dali::DaliException e) {
5712       {
5713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5714       };
5715     } catch (...) {
5716       {
5717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5718       };
5719     }
5720   }
5721
5722   jresult = (void *)result;
5723   return jresult;
5724 }
5725
5726
5727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5728   void * jresult ;
5729   Dali::Vector4 *arg1 = 0 ;
5730   Dali::Vector3 *result = 0 ;
5731
5732   arg1 = (Dali::Vector4 *)jarg1;
5733   if (!arg1) {
5734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5735     return 0;
5736   }
5737   {
5738     try {
5739       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5740     } catch (std::out_of_range& e) {
5741       {
5742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5743       };
5744     } catch (std::exception& e) {
5745       {
5746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5747       };
5748     } catch (Dali::DaliException e) {
5749       {
5750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5751       };
5752     } catch (...) {
5753       {
5754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5755       };
5756     }
5757   }
5758
5759   jresult = (void *)result;
5760   return jresult;
5761 }
5762
5763
5764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5765   void * jresult ;
5766   Dali::Vector3 *result = 0 ;
5767
5768   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5769   jresult = (void *)result;
5770   return jresult;
5771 }
5772
5773
5774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5775   void * jresult ;
5776   Dali::Vector3 *result = 0 ;
5777
5778   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5779   jresult = (void *)result;
5780   return jresult;
5781 }
5782
5783
5784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5785   void * jresult ;
5786   Dali::Vector3 *result = 0 ;
5787
5788   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5789   jresult = (void *)result;
5790   return jresult;
5791 }
5792
5793
5794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5795   void * jresult ;
5796   Dali::Vector3 *result = 0 ;
5797
5798   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5799   jresult = (void *)result;
5800   return jresult;
5801 }
5802
5803
5804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5805   void * jresult ;
5806   Dali::Vector3 *result = 0 ;
5807
5808   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5809   jresult = (void *)result;
5810   return jresult;
5811 }
5812
5813
5814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5815   void * jresult ;
5816   Dali::Vector3 *result = 0 ;
5817
5818   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5819   jresult = (void *)result;
5820   return jresult;
5821 }
5822
5823
5824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5825   void * jresult ;
5826   Dali::Vector3 *result = 0 ;
5827
5828   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5829   jresult = (void *)result;
5830   return jresult;
5831 }
5832
5833
5834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5835   void * jresult ;
5836   Dali::Vector3 *result = 0 ;
5837
5838   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5839   jresult = (void *)result;
5840   return jresult;
5841 }
5842
5843
5844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5845   void * jresult ;
5846   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5847   float *arg2 = (float *) 0 ;
5848   Dali::Vector3 *result = 0 ;
5849
5850   arg1 = (Dali::Vector3 *)jarg1;
5851   arg2 = jarg2;
5852   {
5853     try {
5854       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5855     } catch (std::out_of_range& e) {
5856       {
5857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5858       };
5859     } catch (std::exception& e) {
5860       {
5861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5862       };
5863     } catch (Dali::DaliException e) {
5864       {
5865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5866       };
5867     } catch (...) {
5868       {
5869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5870       };
5871     }
5872   }
5873
5874   jresult = (void *)result;
5875
5876
5877   return jresult;
5878 }
5879
5880
5881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5882   void * jresult ;
5883   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5884   Dali::Vector2 *arg2 = 0 ;
5885   Dali::Vector3 *result = 0 ;
5886
5887   arg1 = (Dali::Vector3 *)jarg1;
5888   arg2 = (Dali::Vector2 *)jarg2;
5889   if (!arg2) {
5890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5891     return 0;
5892   }
5893   {
5894     try {
5895       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5896     } catch (std::out_of_range& e) {
5897       {
5898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5899       };
5900     } catch (std::exception& e) {
5901       {
5902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5903       };
5904     } catch (Dali::DaliException e) {
5905       {
5906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5907       };
5908     } catch (...) {
5909       {
5910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5911       };
5912     }
5913   }
5914
5915   jresult = (void *)result;
5916   return jresult;
5917 }
5918
5919
5920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5921   void * jresult ;
5922   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5923   Dali::Vector4 *arg2 = 0 ;
5924   Dali::Vector3 *result = 0 ;
5925
5926   arg1 = (Dali::Vector3 *)jarg1;
5927   arg2 = (Dali::Vector4 *)jarg2;
5928   if (!arg2) {
5929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5930     return 0;
5931   }
5932   {
5933     try {
5934       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5935     } catch (std::out_of_range& e) {
5936       {
5937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5938       };
5939     } catch (std::exception& e) {
5940       {
5941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5942       };
5943     } catch (Dali::DaliException e) {
5944       {
5945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5946       };
5947     } catch (...) {
5948       {
5949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5950       };
5951     }
5952   }
5953
5954   jresult = (void *)result;
5955   return jresult;
5956 }
5957
5958
5959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5960   void * jresult ;
5961   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5962   Dali::Vector3 *arg2 = 0 ;
5963   Dali::Vector3 result;
5964
5965   arg1 = (Dali::Vector3 *)jarg1;
5966   arg2 = (Dali::Vector3 *)jarg2;
5967   if (!arg2) {
5968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5969     return 0;
5970   }
5971   {
5972     try {
5973       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5974     } catch (std::out_of_range& e) {
5975       {
5976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5977       };
5978     } catch (std::exception& e) {
5979       {
5980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5981       };
5982     } catch (Dali::DaliException e) {
5983       {
5984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5985       };
5986     } catch (...) {
5987       {
5988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5989       };
5990     }
5991   }
5992
5993   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5994   return jresult;
5995 }
5996
5997
5998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5999   void * jresult ;
6000   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6001   Dali::Vector3 *arg2 = 0 ;
6002   Dali::Vector3 *result = 0 ;
6003
6004   arg1 = (Dali::Vector3 *)jarg1;
6005   arg2 = (Dali::Vector3 *)jarg2;
6006   if (!arg2) {
6007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6008     return 0;
6009   }
6010   {
6011     try {
6012       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6013     } catch (std::out_of_range& e) {
6014       {
6015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6016       };
6017     } catch (std::exception& e) {
6018       {
6019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6020       };
6021     } catch (Dali::DaliException e) {
6022       {
6023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6024       };
6025     } catch (...) {
6026       {
6027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6028       };
6029     }
6030   }
6031
6032   jresult = (void *)result;
6033   return jresult;
6034 }
6035
6036
6037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6038   void * jresult ;
6039   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6040   Dali::Vector3 *arg2 = 0 ;
6041   Dali::Vector3 result;
6042
6043   arg1 = (Dali::Vector3 *)jarg1;
6044   arg2 = (Dali::Vector3 *)jarg2;
6045   if (!arg2) {
6046     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6047     return 0;
6048   }
6049   {
6050     try {
6051       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6052     } catch (std::out_of_range& e) {
6053       {
6054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6055       };
6056     } catch (std::exception& e) {
6057       {
6058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6059       };
6060     } catch (Dali::DaliException e) {
6061       {
6062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6063       };
6064     } catch (...) {
6065       {
6066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6067       };
6068     }
6069   }
6070
6071   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6072   return jresult;
6073 }
6074
6075
6076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6077   void * jresult ;
6078   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6079   Dali::Vector3 *arg2 = 0 ;
6080   Dali::Vector3 *result = 0 ;
6081
6082   arg1 = (Dali::Vector3 *)jarg1;
6083   arg2 = (Dali::Vector3 *)jarg2;
6084   if (!arg2) {
6085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6086     return 0;
6087   }
6088   {
6089     try {
6090       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6091     } catch (std::out_of_range& e) {
6092       {
6093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6094       };
6095     } catch (std::exception& e) {
6096       {
6097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6098       };
6099     } catch (Dali::DaliException e) {
6100       {
6101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6102       };
6103     } catch (...) {
6104       {
6105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6106       };
6107     }
6108   }
6109
6110   jresult = (void *)result;
6111   return jresult;
6112 }
6113
6114
6115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6116   void * jresult ;
6117   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6118   Dali::Vector3 *arg2 = 0 ;
6119   Dali::Vector3 result;
6120
6121   arg1 = (Dali::Vector3 *)jarg1;
6122   arg2 = (Dali::Vector3 *)jarg2;
6123   if (!arg2) {
6124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6125     return 0;
6126   }
6127   {
6128     try {
6129       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6130     } catch (std::out_of_range& e) {
6131       {
6132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6133       };
6134     } catch (std::exception& e) {
6135       {
6136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6137       };
6138     } catch (Dali::DaliException e) {
6139       {
6140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6141       };
6142     } catch (...) {
6143       {
6144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6145       };
6146     }
6147   }
6148
6149   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6150   return jresult;
6151 }
6152
6153
6154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6155   void * jresult ;
6156   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6157   float arg2 ;
6158   Dali::Vector3 result;
6159
6160   arg1 = (Dali::Vector3 *)jarg1;
6161   arg2 = (float)jarg2;
6162   {
6163     try {
6164       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6165     } catch (std::out_of_range& e) {
6166       {
6167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6168       };
6169     } catch (std::exception& e) {
6170       {
6171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6172       };
6173     } catch (Dali::DaliException e) {
6174       {
6175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6176       };
6177     } catch (...) {
6178       {
6179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6180       };
6181     }
6182   }
6183
6184   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6185   return jresult;
6186 }
6187
6188
6189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6190   void * jresult ;
6191   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6192   Dali::Vector3 *arg2 = 0 ;
6193   Dali::Vector3 *result = 0 ;
6194
6195   arg1 = (Dali::Vector3 *)jarg1;
6196   arg2 = (Dali::Vector3 *)jarg2;
6197   if (!arg2) {
6198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6199     return 0;
6200   }
6201   {
6202     try {
6203       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6204     } catch (std::out_of_range& e) {
6205       {
6206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6207       };
6208     } catch (std::exception& e) {
6209       {
6210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6211       };
6212     } catch (Dali::DaliException e) {
6213       {
6214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6215       };
6216     } catch (...) {
6217       {
6218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6219       };
6220     }
6221   }
6222
6223   jresult = (void *)result;
6224   return jresult;
6225 }
6226
6227
6228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6229   void * jresult ;
6230   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6231   float arg2 ;
6232   Dali::Vector3 *result = 0 ;
6233
6234   arg1 = (Dali::Vector3 *)jarg1;
6235   arg2 = (float)jarg2;
6236   {
6237     try {
6238       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6239     } catch (std::out_of_range& e) {
6240       {
6241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6242       };
6243     } catch (std::exception& e) {
6244       {
6245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6246       };
6247     } catch (Dali::DaliException e) {
6248       {
6249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6250       };
6251     } catch (...) {
6252       {
6253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6254       };
6255     }
6256   }
6257
6258   jresult = (void *)result;
6259   return jresult;
6260 }
6261
6262
6263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6264   void * jresult ;
6265   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6266   Dali::Quaternion *arg2 = 0 ;
6267   Dali::Vector3 *result = 0 ;
6268
6269   arg1 = (Dali::Vector3 *)jarg1;
6270   arg2 = (Dali::Quaternion *)jarg2;
6271   if (!arg2) {
6272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6273     return 0;
6274   }
6275   {
6276     try {
6277       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6278     } catch (std::out_of_range& e) {
6279       {
6280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6281       };
6282     } catch (std::exception& e) {
6283       {
6284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6285       };
6286     } catch (Dali::DaliException e) {
6287       {
6288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6289       };
6290     } catch (...) {
6291       {
6292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6293       };
6294     }
6295   }
6296
6297   jresult = (void *)result;
6298   return jresult;
6299 }
6300
6301
6302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6303   void * jresult ;
6304   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6305   Dali::Vector3 *arg2 = 0 ;
6306   Dali::Vector3 result;
6307
6308   arg1 = (Dali::Vector3 *)jarg1;
6309   arg2 = (Dali::Vector3 *)jarg2;
6310   if (!arg2) {
6311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6312     return 0;
6313   }
6314   {
6315     try {
6316       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6317     } catch (std::out_of_range& e) {
6318       {
6319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6320       };
6321     } catch (std::exception& e) {
6322       {
6323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6324       };
6325     } catch (Dali::DaliException e) {
6326       {
6327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6328       };
6329     } catch (...) {
6330       {
6331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6332       };
6333     }
6334   }
6335
6336   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6337   return jresult;
6338 }
6339
6340
6341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6342   void * jresult ;
6343   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6344   float arg2 ;
6345   Dali::Vector3 result;
6346
6347   arg1 = (Dali::Vector3 *)jarg1;
6348   arg2 = (float)jarg2;
6349   {
6350     try {
6351       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6352     } catch (std::out_of_range& e) {
6353       {
6354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6355       };
6356     } catch (std::exception& e) {
6357       {
6358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6359       };
6360     } catch (Dali::DaliException e) {
6361       {
6362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6363       };
6364     } catch (...) {
6365       {
6366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6367       };
6368     }
6369   }
6370
6371   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6372   return jresult;
6373 }
6374
6375
6376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6377   void * jresult ;
6378   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6379   Dali::Vector3 *arg2 = 0 ;
6380   Dali::Vector3 *result = 0 ;
6381
6382   arg1 = (Dali::Vector3 *)jarg1;
6383   arg2 = (Dali::Vector3 *)jarg2;
6384   if (!arg2) {
6385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6386     return 0;
6387   }
6388   {
6389     try {
6390       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6391     } catch (std::out_of_range& e) {
6392       {
6393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6394       };
6395     } catch (std::exception& e) {
6396       {
6397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6398       };
6399     } catch (Dali::DaliException e) {
6400       {
6401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6402       };
6403     } catch (...) {
6404       {
6405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6406       };
6407     }
6408   }
6409
6410   jresult = (void *)result;
6411   return jresult;
6412 }
6413
6414
6415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6416   void * jresult ;
6417   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6418   float arg2 ;
6419   Dali::Vector3 *result = 0 ;
6420
6421   arg1 = (Dali::Vector3 *)jarg1;
6422   arg2 = (float)jarg2;
6423   {
6424     try {
6425       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6426     } catch (std::out_of_range& e) {
6427       {
6428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6429       };
6430     } catch (std::exception& e) {
6431       {
6432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6433       };
6434     } catch (Dali::DaliException e) {
6435       {
6436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6437       };
6438     } catch (...) {
6439       {
6440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6441       };
6442     }
6443   }
6444
6445   jresult = (void *)result;
6446   return jresult;
6447 }
6448
6449
6450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6451   void * jresult ;
6452   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6453   Dali::Vector3 result;
6454
6455   arg1 = (Dali::Vector3 *)jarg1;
6456   {
6457     try {
6458       result = ((Dali::Vector3 const *)arg1)->operator -();
6459     } catch (std::out_of_range& e) {
6460       {
6461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6462       };
6463     } catch (std::exception& e) {
6464       {
6465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6466       };
6467     } catch (Dali::DaliException e) {
6468       {
6469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6470       };
6471     } catch (...) {
6472       {
6473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6474       };
6475     }
6476   }
6477
6478   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6479   return jresult;
6480 }
6481
6482
6483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6484   unsigned int jresult ;
6485   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6486   Dali::Vector3 *arg2 = 0 ;
6487   bool result;
6488
6489   arg1 = (Dali::Vector3 *)jarg1;
6490   arg2 = (Dali::Vector3 *)jarg2;
6491   if (!arg2) {
6492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6493     return 0;
6494   }
6495   {
6496     try {
6497       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6498     } catch (std::out_of_range& e) {
6499       {
6500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6501       };
6502     } catch (std::exception& e) {
6503       {
6504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6505       };
6506     } catch (Dali::DaliException e) {
6507       {
6508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6509       };
6510     } catch (...) {
6511       {
6512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6513       };
6514     }
6515   }
6516
6517   jresult = result;
6518   return jresult;
6519 }
6520
6521
6522 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6523   unsigned int jresult ;
6524   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6525   Dali::Vector3 *arg2 = 0 ;
6526   bool result;
6527
6528   arg1 = (Dali::Vector3 *)jarg1;
6529   arg2 = (Dali::Vector3 *)jarg2;
6530   if (!arg2) {
6531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6532     return 0;
6533   }
6534   {
6535     try {
6536       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6537     } catch (std::out_of_range& e) {
6538       {
6539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6540       };
6541     } catch (std::exception& e) {
6542       {
6543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6544       };
6545     } catch (Dali::DaliException e) {
6546       {
6547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6548       };
6549     } catch (...) {
6550       {
6551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6552       };
6553     }
6554   }
6555
6556   jresult = result;
6557   return jresult;
6558 }
6559
6560
6561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6562   float jresult ;
6563   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6564   unsigned int arg2 ;
6565   float *result = 0 ;
6566
6567   arg1 = (Dali::Vector3 *)jarg1;
6568   arg2 = (unsigned int)jarg2;
6569   {
6570     try {
6571       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6572     } catch (std::out_of_range& e) {
6573       {
6574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6575       };
6576     } catch (std::exception& e) {
6577       {
6578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6579       };
6580     } catch (Dali::DaliException e) {
6581       {
6582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6583       };
6584     } catch (...) {
6585       {
6586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6587       };
6588     }
6589   }
6590
6591   jresult = *result;
6592   return jresult;
6593 }
6594
6595
6596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6597   float jresult ;
6598   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6599   Dali::Vector3 *arg2 = 0 ;
6600   float result;
6601
6602   arg1 = (Dali::Vector3 *)jarg1;
6603   arg2 = (Dali::Vector3 *)jarg2;
6604   if (!arg2) {
6605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6606     return 0;
6607   }
6608   {
6609     try {
6610       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6611     } catch (std::out_of_range& e) {
6612       {
6613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6614       };
6615     } catch (std::exception& e) {
6616       {
6617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6618       };
6619     } catch (Dali::DaliException e) {
6620       {
6621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6622       };
6623     } catch (...) {
6624       {
6625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6626       };
6627     }
6628   }
6629
6630   jresult = result;
6631   return jresult;
6632 }
6633
6634
6635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6636   void * jresult ;
6637   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6638   Dali::Vector3 *arg2 = 0 ;
6639   Dali::Vector3 result;
6640
6641   arg1 = (Dali::Vector3 *)jarg1;
6642   arg2 = (Dali::Vector3 *)jarg2;
6643   if (!arg2) {
6644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6645     return 0;
6646   }
6647   {
6648     try {
6649       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6650     } catch (std::out_of_range& e) {
6651       {
6652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6653       };
6654     } catch (std::exception& e) {
6655       {
6656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6657       };
6658     } catch (Dali::DaliException e) {
6659       {
6660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6661       };
6662     } catch (...) {
6663       {
6664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6665       };
6666     }
6667   }
6668
6669   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6670   return jresult;
6671 }
6672
6673
6674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6675   float jresult ;
6676   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6677   float result;
6678
6679   arg1 = (Dali::Vector3 *)jarg1;
6680   {
6681     try {
6682       result = (float)((Dali::Vector3 const *)arg1)->Length();
6683     } catch (std::out_of_range& e) {
6684       {
6685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6686       };
6687     } catch (std::exception& e) {
6688       {
6689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6690       };
6691     } catch (Dali::DaliException e) {
6692       {
6693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6694       };
6695     } catch (...) {
6696       {
6697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6698       };
6699     }
6700   }
6701
6702   jresult = result;
6703   return jresult;
6704 }
6705
6706
6707 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6708   float jresult ;
6709   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6710   float result;
6711
6712   arg1 = (Dali::Vector3 *)jarg1;
6713   {
6714     try {
6715       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6716     } catch (std::out_of_range& e) {
6717       {
6718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6719       };
6720     } catch (std::exception& e) {
6721       {
6722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6723       };
6724     } catch (Dali::DaliException e) {
6725       {
6726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6727       };
6728     } catch (...) {
6729       {
6730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6731       };
6732     }
6733   }
6734
6735   jresult = result;
6736   return jresult;
6737 }
6738
6739
6740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6741   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6742
6743   arg1 = (Dali::Vector3 *)jarg1;
6744   {
6745     try {
6746       (arg1)->Normalize();
6747     } catch (std::out_of_range& e) {
6748       {
6749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6750       };
6751     } catch (std::exception& e) {
6752       {
6753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6754       };
6755     } catch (Dali::DaliException e) {
6756       {
6757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6758       };
6759     } catch (...) {
6760       {
6761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6762       };
6763     }
6764   }
6765
6766 }
6767
6768
6769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6770   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6771   Dali::Vector3 *arg2 = 0 ;
6772   Dali::Vector3 *arg3 = 0 ;
6773
6774   arg1 = (Dali::Vector3 *)jarg1;
6775   arg2 = (Dali::Vector3 *)jarg2;
6776   if (!arg2) {
6777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6778     return ;
6779   }
6780   arg3 = (Dali::Vector3 *)jarg3;
6781   if (!arg3) {
6782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6783     return ;
6784   }
6785   {
6786     try {
6787       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6788     } catch (std::out_of_range& e) {
6789       {
6790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6791       };
6792     } catch (std::exception& e) {
6793       {
6794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6795       };
6796     } catch (Dali::DaliException e) {
6797       {
6798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6799       };
6800     } catch (...) {
6801       {
6802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6803       };
6804     }
6805   }
6806
6807 }
6808
6809
6810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6811   void * jresult ;
6812   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6813   float *result = 0 ;
6814
6815   arg1 = (Dali::Vector3 *)jarg1;
6816   {
6817     try {
6818       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6819     } catch (std::out_of_range& e) {
6820       {
6821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6822       };
6823     } catch (std::exception& e) {
6824       {
6825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6826       };
6827     } catch (Dali::DaliException e) {
6828       {
6829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6830       };
6831     } catch (...) {
6832       {
6833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6834       };
6835     }
6836   }
6837
6838   jresult = (void *)result;
6839   return jresult;
6840 }
6841
6842
6843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6844   void * jresult ;
6845   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6846   Dali::Vector2 *result = 0 ;
6847
6848   arg1 = (Dali::Vector3 *)jarg1;
6849   {
6850     try {
6851       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6852     } catch (std::out_of_range& e) {
6853       {
6854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6855       };
6856     } catch (std::exception& e) {
6857       {
6858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6859       };
6860     } catch (Dali::DaliException e) {
6861       {
6862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6863       };
6864     } catch (...) {
6865       {
6866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6867       };
6868     }
6869   }
6870
6871   jresult = (void *)result;
6872   return jresult;
6873 }
6874
6875
6876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6877   void * jresult ;
6878   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6879   Dali::Vector2 *result = 0 ;
6880
6881   arg1 = (Dali::Vector3 *)jarg1;
6882   {
6883     try {
6884       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6885     } catch (std::out_of_range& e) {
6886       {
6887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6888       };
6889     } catch (std::exception& e) {
6890       {
6891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6892       };
6893     } catch (Dali::DaliException e) {
6894       {
6895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6896       };
6897     } catch (...) {
6898       {
6899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6900       };
6901     }
6902   }
6903
6904   jresult = (void *)result;
6905   return jresult;
6906 }
6907
6908
6909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6910   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6911   float arg2 ;
6912
6913   arg1 = (Dali::Vector3 *)jarg1;
6914   arg2 = (float)jarg2;
6915   if (arg1) (arg1)->x = arg2;
6916 }
6917
6918
6919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6920   float jresult ;
6921   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6922   float result;
6923
6924   arg1 = (Dali::Vector3 *)jarg1;
6925   result = (float) ((arg1)->x);
6926   jresult = result;
6927   return jresult;
6928 }
6929
6930
6931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6932   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6933   float arg2 ;
6934
6935   arg1 = (Dali::Vector3 *)jarg1;
6936   arg2 = (float)jarg2;
6937   if (arg1) (arg1)->width = arg2;
6938 }
6939
6940
6941 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6942   float jresult ;
6943   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6944   float result;
6945
6946   arg1 = (Dali::Vector3 *)jarg1;
6947   result = (float) ((arg1)->width);
6948   jresult = result;
6949   return jresult;
6950 }
6951
6952
6953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6954   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6955   float arg2 ;
6956
6957   arg1 = (Dali::Vector3 *)jarg1;
6958   arg2 = (float)jarg2;
6959   if (arg1) (arg1)->r = arg2;
6960 }
6961
6962
6963 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6964   float jresult ;
6965   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6966   float result;
6967
6968   arg1 = (Dali::Vector3 *)jarg1;
6969   result = (float) ((arg1)->r);
6970   jresult = result;
6971   return jresult;
6972 }
6973
6974
6975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6976   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6977   float arg2 ;
6978
6979   arg1 = (Dali::Vector3 *)jarg1;
6980   arg2 = (float)jarg2;
6981   if (arg1) (arg1)->y = arg2;
6982 }
6983
6984
6985 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6986   float jresult ;
6987   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6988   float result;
6989
6990   arg1 = (Dali::Vector3 *)jarg1;
6991   result = (float) ((arg1)->y);
6992   jresult = result;
6993   return jresult;
6994 }
6995
6996
6997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6998   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6999   float arg2 ;
7000
7001   arg1 = (Dali::Vector3 *)jarg1;
7002   arg2 = (float)jarg2;
7003   if (arg1) (arg1)->height = arg2;
7004 }
7005
7006
7007 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7008   float jresult ;
7009   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7010   float result;
7011
7012   arg1 = (Dali::Vector3 *)jarg1;
7013   result = (float) ((arg1)->height);
7014   jresult = result;
7015   return jresult;
7016 }
7017
7018
7019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7020   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7021   float arg2 ;
7022
7023   arg1 = (Dali::Vector3 *)jarg1;
7024   arg2 = (float)jarg2;
7025   if (arg1) (arg1)->g = arg2;
7026 }
7027
7028
7029 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7030   float jresult ;
7031   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7032   float result;
7033
7034   arg1 = (Dali::Vector3 *)jarg1;
7035   result = (float) ((arg1)->g);
7036   jresult = result;
7037   return jresult;
7038 }
7039
7040
7041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7042   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7043   float arg2 ;
7044
7045   arg1 = (Dali::Vector3 *)jarg1;
7046   arg2 = (float)jarg2;
7047   if (arg1) (arg1)->z = arg2;
7048 }
7049
7050
7051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7052   float jresult ;
7053   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7054   float result;
7055
7056   arg1 = (Dali::Vector3 *)jarg1;
7057   result = (float) ((arg1)->z);
7058   jresult = result;
7059   return jresult;
7060 }
7061
7062
7063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7064   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7065   float arg2 ;
7066
7067   arg1 = (Dali::Vector3 *)jarg1;
7068   arg2 = (float)jarg2;
7069   if (arg1) (arg1)->depth = arg2;
7070 }
7071
7072
7073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7074   float jresult ;
7075   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7076   float result;
7077
7078   arg1 = (Dali::Vector3 *)jarg1;
7079   result = (float) ((arg1)->depth);
7080   jresult = result;
7081   return jresult;
7082 }
7083
7084
7085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7086   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7087   float arg2 ;
7088
7089   arg1 = (Dali::Vector3 *)jarg1;
7090   arg2 = (float)jarg2;
7091   if (arg1) (arg1)->b = arg2;
7092 }
7093
7094
7095 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7096   float jresult ;
7097   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7098   float result;
7099
7100   arg1 = (Dali::Vector3 *)jarg1;
7101   result = (float) ((arg1)->b);
7102   jresult = result;
7103   return jresult;
7104 }
7105
7106
7107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7108   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7109
7110   arg1 = (Dali::Vector3 *)jarg1;
7111   {
7112     try {
7113       delete arg1;
7114     } catch (std::out_of_range& e) {
7115       {
7116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7117       };
7118     } catch (std::exception& e) {
7119       {
7120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7121       };
7122     } catch (Dali::DaliException e) {
7123       {
7124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7125       };
7126     } catch (...) {
7127       {
7128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7129       };
7130     }
7131   }
7132
7133 }
7134
7135
7136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7137   void * jresult ;
7138   Dali::Vector3 *arg1 = 0 ;
7139   Dali::Vector3 *arg2 = 0 ;
7140   Dali::Vector3 result;
7141
7142   arg1 = (Dali::Vector3 *)jarg1;
7143   if (!arg1) {
7144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7145     return 0;
7146   }
7147   arg2 = (Dali::Vector3 *)jarg2;
7148   if (!arg2) {
7149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7150     return 0;
7151   }
7152   {
7153     try {
7154       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7155     } catch (std::out_of_range& e) {
7156       {
7157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7158       };
7159     } catch (std::exception& e) {
7160       {
7161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7162       };
7163     } catch (Dali::DaliException e) {
7164       {
7165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7166       };
7167     } catch (...) {
7168       {
7169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7170       };
7171     }
7172   }
7173
7174   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7175   return jresult;
7176 }
7177
7178
7179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7180   void * jresult ;
7181   Dali::Vector3 *arg1 = 0 ;
7182   Dali::Vector3 *arg2 = 0 ;
7183   Dali::Vector3 result;
7184
7185   arg1 = (Dali::Vector3 *)jarg1;
7186   if (!arg1) {
7187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7188     return 0;
7189   }
7190   arg2 = (Dali::Vector3 *)jarg2;
7191   if (!arg2) {
7192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7193     return 0;
7194   }
7195   {
7196     try {
7197       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7198     } catch (std::out_of_range& e) {
7199       {
7200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (std::exception& e) {
7203       {
7204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7205       };
7206     } catch (Dali::DaliException e) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7209       };
7210     } catch (...) {
7211       {
7212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7213       };
7214     }
7215   }
7216
7217   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7218   return jresult;
7219 }
7220
7221
7222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7223   void * jresult ;
7224   Dali::Vector3 *arg1 = 0 ;
7225   float *arg2 = 0 ;
7226   float *arg3 = 0 ;
7227   float temp2 ;
7228   float temp3 ;
7229   Dali::Vector3 result;
7230
7231   arg1 = (Dali::Vector3 *)jarg1;
7232   if (!arg1) {
7233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7234     return 0;
7235   }
7236   temp2 = (float)jarg2;
7237   arg2 = &temp2;
7238   temp3 = (float)jarg3;
7239   arg3 = &temp3;
7240   {
7241     try {
7242       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7243     } catch (std::out_of_range& e) {
7244       {
7245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7246       };
7247     } catch (std::exception& e) {
7248       {
7249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7250       };
7251     } catch (Dali::DaliException e) {
7252       {
7253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7254       };
7255     } catch (...) {
7256       {
7257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7258       };
7259     }
7260   }
7261
7262   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7263   return jresult;
7264 }
7265
7266
7267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7268   void * jresult ;
7269   Dali::Vector4 *result = 0 ;
7270
7271   {
7272     try {
7273       result = (Dali::Vector4 *)new Dali::Vector4();
7274     } catch (std::out_of_range& e) {
7275       {
7276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7277       };
7278     } catch (std::exception& e) {
7279       {
7280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7281       };
7282     } catch (Dali::DaliException e) {
7283       {
7284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7285       };
7286     } catch (...) {
7287       {
7288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7289       };
7290     }
7291   }
7292
7293   jresult = (void *)result;
7294   return jresult;
7295 }
7296
7297
7298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7299   void * jresult ;
7300   float arg1 ;
7301   float arg2 ;
7302   float arg3 ;
7303   float arg4 ;
7304   Dali::Vector4 *result = 0 ;
7305
7306   arg1 = (float)jarg1;
7307   arg2 = (float)jarg2;
7308   arg3 = (float)jarg3;
7309   arg4 = (float)jarg4;
7310   {
7311     try {
7312       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7313     } catch (std::out_of_range& e) {
7314       {
7315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7316       };
7317     } catch (std::exception& e) {
7318       {
7319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7320       };
7321     } catch (Dali::DaliException e) {
7322       {
7323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7324       };
7325     } catch (...) {
7326       {
7327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7328       };
7329     }
7330   }
7331
7332   jresult = (void *)result;
7333   return jresult;
7334 }
7335
7336
7337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7338   void * jresult ;
7339   float *arg1 = (float *) 0 ;
7340   Dali::Vector4 *result = 0 ;
7341
7342   arg1 = jarg1;
7343   {
7344     try {
7345       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7346     } catch (std::out_of_range& e) {
7347       {
7348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7349       };
7350     } catch (std::exception& e) {
7351       {
7352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7353       };
7354     } catch (Dali::DaliException e) {
7355       {
7356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7357       };
7358     } catch (...) {
7359       {
7360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7361       };
7362     }
7363   }
7364
7365   jresult = (void *)result;
7366
7367
7368   return jresult;
7369 }
7370
7371
7372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7373   void * jresult ;
7374   Dali::Vector2 *arg1 = 0 ;
7375   Dali::Vector4 *result = 0 ;
7376
7377   arg1 = (Dali::Vector2 *)jarg1;
7378   if (!arg1) {
7379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7380     return 0;
7381   }
7382   {
7383     try {
7384       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7385     } catch (std::out_of_range& e) {
7386       {
7387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7388       };
7389     } catch (std::exception& e) {
7390       {
7391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7392       };
7393     } catch (Dali::DaliException e) {
7394       {
7395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7396       };
7397     } catch (...) {
7398       {
7399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7400       };
7401     }
7402   }
7403
7404   jresult = (void *)result;
7405   return jresult;
7406 }
7407
7408
7409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7410   void * jresult ;
7411   Dali::Vector3 *arg1 = 0 ;
7412   Dali::Vector4 *result = 0 ;
7413
7414   arg1 = (Dali::Vector3 *)jarg1;
7415   if (!arg1) {
7416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7417     return 0;
7418   }
7419   {
7420     try {
7421       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7422     } catch (std::out_of_range& e) {
7423       {
7424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7425       };
7426     } catch (std::exception& e) {
7427       {
7428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7429       };
7430     } catch (Dali::DaliException e) {
7431       {
7432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7433       };
7434     } catch (...) {
7435       {
7436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7437       };
7438     }
7439   }
7440
7441   jresult = (void *)result;
7442   return jresult;
7443 }
7444
7445
7446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7447   void * jresult ;
7448   Dali::Vector4 *result = 0 ;
7449
7450   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7451   jresult = (void *)result;
7452   return jresult;
7453 }
7454
7455
7456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7457   void * jresult ;
7458   Dali::Vector4 *result = 0 ;
7459
7460   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7461   jresult = (void *)result;
7462   return jresult;
7463 }
7464
7465
7466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7467   void * jresult ;
7468   Dali::Vector4 *result = 0 ;
7469
7470   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7471   jresult = (void *)result;
7472   return jresult;
7473 }
7474
7475
7476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7477   void * jresult ;
7478   Dali::Vector4 *result = 0 ;
7479
7480   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7481   jresult = (void *)result;
7482   return jresult;
7483 }
7484
7485
7486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7487   void * jresult ;
7488   Dali::Vector4 *result = 0 ;
7489
7490   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7491   jresult = (void *)result;
7492   return jresult;
7493 }
7494
7495
7496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7497   void * jresult ;
7498   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7499   float *arg2 = (float *) 0 ;
7500   Dali::Vector4 *result = 0 ;
7501
7502   arg1 = (Dali::Vector4 *)jarg1;
7503   arg2 = jarg2;
7504   {
7505     try {
7506       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7507     } catch (std::out_of_range& e) {
7508       {
7509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7510       };
7511     } catch (std::exception& e) {
7512       {
7513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7514       };
7515     } catch (Dali::DaliException e) {
7516       {
7517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7518       };
7519     } catch (...) {
7520       {
7521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7522       };
7523     }
7524   }
7525
7526   jresult = (void *)result;
7527
7528
7529   return jresult;
7530 }
7531
7532
7533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7534   void * jresult ;
7535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7536   Dali::Vector2 *arg2 = 0 ;
7537   Dali::Vector4 *result = 0 ;
7538
7539   arg1 = (Dali::Vector4 *)jarg1;
7540   arg2 = (Dali::Vector2 *)jarg2;
7541   if (!arg2) {
7542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7543     return 0;
7544   }
7545   {
7546     try {
7547       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7548     } catch (std::out_of_range& e) {
7549       {
7550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7551       };
7552     } catch (std::exception& e) {
7553       {
7554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7555       };
7556     } catch (Dali::DaliException e) {
7557       {
7558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7559       };
7560     } catch (...) {
7561       {
7562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7563       };
7564     }
7565   }
7566
7567   jresult = (void *)result;
7568   return jresult;
7569 }
7570
7571
7572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7573   void * jresult ;
7574   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7575   Dali::Vector3 *arg2 = 0 ;
7576   Dali::Vector4 *result = 0 ;
7577
7578   arg1 = (Dali::Vector4 *)jarg1;
7579   arg2 = (Dali::Vector3 *)jarg2;
7580   if (!arg2) {
7581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7582     return 0;
7583   }
7584   {
7585     try {
7586       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7587     } catch (std::out_of_range& e) {
7588       {
7589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7590       };
7591     } catch (std::exception& e) {
7592       {
7593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7594       };
7595     } catch (Dali::DaliException e) {
7596       {
7597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7598       };
7599     } catch (...) {
7600       {
7601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7602       };
7603     }
7604   }
7605
7606   jresult = (void *)result;
7607   return jresult;
7608 }
7609
7610
7611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7612   void * jresult ;
7613   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7614   Dali::Vector4 *arg2 = 0 ;
7615   Dali::Vector4 result;
7616
7617   arg1 = (Dali::Vector4 *)jarg1;
7618   arg2 = (Dali::Vector4 *)jarg2;
7619   if (!arg2) {
7620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7621     return 0;
7622   }
7623   {
7624     try {
7625       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7626     } catch (std::out_of_range& e) {
7627       {
7628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7629       };
7630     } catch (std::exception& e) {
7631       {
7632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7633       };
7634     } catch (Dali::DaliException e) {
7635       {
7636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7637       };
7638     } catch (...) {
7639       {
7640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7641       };
7642     }
7643   }
7644
7645   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7646   return jresult;
7647 }
7648
7649
7650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7651   void * jresult ;
7652   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7653   Dali::Vector4 *arg2 = 0 ;
7654   Dali::Vector4 *result = 0 ;
7655
7656   arg1 = (Dali::Vector4 *)jarg1;
7657   arg2 = (Dali::Vector4 *)jarg2;
7658   if (!arg2) {
7659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7660     return 0;
7661   }
7662   {
7663     try {
7664       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7665     } catch (std::out_of_range& e) {
7666       {
7667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7668       };
7669     } catch (std::exception& e) {
7670       {
7671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7672       };
7673     } catch (Dali::DaliException e) {
7674       {
7675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7676       };
7677     } catch (...) {
7678       {
7679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7680       };
7681     }
7682   }
7683
7684   jresult = (void *)result;
7685   return jresult;
7686 }
7687
7688
7689 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7690   void * jresult ;
7691   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7692   Dali::Vector4 *arg2 = 0 ;
7693   Dali::Vector4 result;
7694
7695   arg1 = (Dali::Vector4 *)jarg1;
7696   arg2 = (Dali::Vector4 *)jarg2;
7697   if (!arg2) {
7698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7699     return 0;
7700   }
7701   {
7702     try {
7703       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7704     } catch (std::out_of_range& e) {
7705       {
7706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7707       };
7708     } catch (std::exception& e) {
7709       {
7710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7711       };
7712     } catch (Dali::DaliException e) {
7713       {
7714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7715       };
7716     } catch (...) {
7717       {
7718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7719       };
7720     }
7721   }
7722
7723   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7724   return jresult;
7725 }
7726
7727
7728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7729   void * jresult ;
7730   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7731   Dali::Vector4 *arg2 = 0 ;
7732   Dali::Vector4 *result = 0 ;
7733
7734   arg1 = (Dali::Vector4 *)jarg1;
7735   arg2 = (Dali::Vector4 *)jarg2;
7736   if (!arg2) {
7737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7738     return 0;
7739   }
7740   {
7741     try {
7742       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7743     } catch (std::out_of_range& e) {
7744       {
7745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7746       };
7747     } catch (std::exception& e) {
7748       {
7749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7750       };
7751     } catch (Dali::DaliException e) {
7752       {
7753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7754       };
7755     } catch (...) {
7756       {
7757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7758       };
7759     }
7760   }
7761
7762   jresult = (void *)result;
7763   return jresult;
7764 }
7765
7766
7767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7768   void * jresult ;
7769   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7770   Dali::Vector4 *arg2 = 0 ;
7771   Dali::Vector4 result;
7772
7773   arg1 = (Dali::Vector4 *)jarg1;
7774   arg2 = (Dali::Vector4 *)jarg2;
7775   if (!arg2) {
7776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7777     return 0;
7778   }
7779   {
7780     try {
7781       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7782     } catch (std::out_of_range& e) {
7783       {
7784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7785       };
7786     } catch (std::exception& e) {
7787       {
7788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7789       };
7790     } catch (Dali::DaliException e) {
7791       {
7792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7793       };
7794     } catch (...) {
7795       {
7796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7797       };
7798     }
7799   }
7800
7801   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7802   return jresult;
7803 }
7804
7805
7806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7807   void * jresult ;
7808   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7809   float arg2 ;
7810   Dali::Vector4 result;
7811
7812   arg1 = (Dali::Vector4 *)jarg1;
7813   arg2 = (float)jarg2;
7814   {
7815     try {
7816       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7817     } catch (std::out_of_range& e) {
7818       {
7819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7820       };
7821     } catch (std::exception& e) {
7822       {
7823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7824       };
7825     } catch (Dali::DaliException e) {
7826       {
7827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7828       };
7829     } catch (...) {
7830       {
7831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7832       };
7833     }
7834   }
7835
7836   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7837   return jresult;
7838 }
7839
7840
7841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7842   void * jresult ;
7843   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7844   Dali::Vector4 *arg2 = 0 ;
7845   Dali::Vector4 *result = 0 ;
7846
7847   arg1 = (Dali::Vector4 *)jarg1;
7848   arg2 = (Dali::Vector4 *)jarg2;
7849   if (!arg2) {
7850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7851     return 0;
7852   }
7853   {
7854     try {
7855       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7856     } catch (std::out_of_range& e) {
7857       {
7858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7859       };
7860     } catch (std::exception& e) {
7861       {
7862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7863       };
7864     } catch (Dali::DaliException e) {
7865       {
7866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7867       };
7868     } catch (...) {
7869       {
7870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7871       };
7872     }
7873   }
7874
7875   jresult = (void *)result;
7876   return jresult;
7877 }
7878
7879
7880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7881   void * jresult ;
7882   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7883   float arg2 ;
7884   Dali::Vector4 *result = 0 ;
7885
7886   arg1 = (Dali::Vector4 *)jarg1;
7887   arg2 = (float)jarg2;
7888   {
7889     try {
7890       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7891     } catch (std::out_of_range& e) {
7892       {
7893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7894       };
7895     } catch (std::exception& e) {
7896       {
7897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7898       };
7899     } catch (Dali::DaliException e) {
7900       {
7901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7902       };
7903     } catch (...) {
7904       {
7905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7906       };
7907     }
7908   }
7909
7910   jresult = (void *)result;
7911   return jresult;
7912 }
7913
7914
7915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7916   void * jresult ;
7917   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7918   Dali::Vector4 *arg2 = 0 ;
7919   Dali::Vector4 result;
7920
7921   arg1 = (Dali::Vector4 *)jarg1;
7922   arg2 = (Dali::Vector4 *)jarg2;
7923   if (!arg2) {
7924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7925     return 0;
7926   }
7927   {
7928     try {
7929       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7930     } catch (std::out_of_range& e) {
7931       {
7932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7933       };
7934     } catch (std::exception& e) {
7935       {
7936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7937       };
7938     } catch (Dali::DaliException e) {
7939       {
7940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7941       };
7942     } catch (...) {
7943       {
7944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7945       };
7946     }
7947   }
7948
7949   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7950   return jresult;
7951 }
7952
7953
7954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7955   void * jresult ;
7956   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7957   float arg2 ;
7958   Dali::Vector4 result;
7959
7960   arg1 = (Dali::Vector4 *)jarg1;
7961   arg2 = (float)jarg2;
7962   {
7963     try {
7964       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7965     } catch (std::out_of_range& e) {
7966       {
7967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7968       };
7969     } catch (std::exception& e) {
7970       {
7971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7972       };
7973     } catch (Dali::DaliException e) {
7974       {
7975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7976       };
7977     } catch (...) {
7978       {
7979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7980       };
7981     }
7982   }
7983
7984   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7985   return jresult;
7986 }
7987
7988
7989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7990   void * jresult ;
7991   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7992   Dali::Vector4 *arg2 = 0 ;
7993   Dali::Vector4 *result = 0 ;
7994
7995   arg1 = (Dali::Vector4 *)jarg1;
7996   arg2 = (Dali::Vector4 *)jarg2;
7997   if (!arg2) {
7998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7999     return 0;
8000   }
8001   {
8002     try {
8003       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8004     } catch (std::out_of_range& e) {
8005       {
8006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8007       };
8008     } catch (std::exception& e) {
8009       {
8010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8011       };
8012     } catch (Dali::DaliException e) {
8013       {
8014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8015       };
8016     } catch (...) {
8017       {
8018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8019       };
8020     }
8021   }
8022
8023   jresult = (void *)result;
8024   return jresult;
8025 }
8026
8027
8028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8029   void * jresult ;
8030   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8031   float arg2 ;
8032   Dali::Vector4 *result = 0 ;
8033
8034   arg1 = (Dali::Vector4 *)jarg1;
8035   arg2 = (float)jarg2;
8036   {
8037     try {
8038       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8039     } catch (std::out_of_range& e) {
8040       {
8041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8042       };
8043     } catch (std::exception& e) {
8044       {
8045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8046       };
8047     } catch (Dali::DaliException e) {
8048       {
8049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8050       };
8051     } catch (...) {
8052       {
8053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8054       };
8055     }
8056   }
8057
8058   jresult = (void *)result;
8059   return jresult;
8060 }
8061
8062
8063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8064   void * jresult ;
8065   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8066   Dali::Vector4 result;
8067
8068   arg1 = (Dali::Vector4 *)jarg1;
8069   {
8070     try {
8071       result = ((Dali::Vector4 const *)arg1)->operator -();
8072     } catch (std::out_of_range& e) {
8073       {
8074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8075       };
8076     } catch (std::exception& e) {
8077       {
8078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8079       };
8080     } catch (Dali::DaliException e) {
8081       {
8082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8083       };
8084     } catch (...) {
8085       {
8086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8087       };
8088     }
8089   }
8090
8091   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8092   return jresult;
8093 }
8094
8095
8096 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8097   unsigned int jresult ;
8098   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8099   Dali::Vector4 *arg2 = 0 ;
8100   bool result;
8101
8102   arg1 = (Dali::Vector4 *)jarg1;
8103   arg2 = (Dali::Vector4 *)jarg2;
8104   if (!arg2) {
8105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8106     return 0;
8107   }
8108   {
8109     try {
8110       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8111     } catch (std::out_of_range& e) {
8112       {
8113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8114       };
8115     } catch (std::exception& e) {
8116       {
8117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8118       };
8119     } catch (Dali::DaliException e) {
8120       {
8121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8122       };
8123     } catch (...) {
8124       {
8125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8126       };
8127     }
8128   }
8129
8130   jresult = result;
8131   return jresult;
8132 }
8133
8134
8135 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8136   unsigned int jresult ;
8137   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8138   Dali::Vector4 *arg2 = 0 ;
8139   bool result;
8140
8141   arg1 = (Dali::Vector4 *)jarg1;
8142   arg2 = (Dali::Vector4 *)jarg2;
8143   if (!arg2) {
8144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8145     return 0;
8146   }
8147   {
8148     try {
8149       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8150     } catch (std::out_of_range& e) {
8151       {
8152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8153       };
8154     } catch (std::exception& e) {
8155       {
8156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8157       };
8158     } catch (Dali::DaliException e) {
8159       {
8160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8161       };
8162     } catch (...) {
8163       {
8164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8165       };
8166     }
8167   }
8168
8169   jresult = result;
8170   return jresult;
8171 }
8172
8173
8174 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8175   float jresult ;
8176   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8177   unsigned int arg2 ;
8178   float *result = 0 ;
8179
8180   arg1 = (Dali::Vector4 *)jarg1;
8181   arg2 = (unsigned int)jarg2;
8182   {
8183     try {
8184       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8185     } catch (std::out_of_range& e) {
8186       {
8187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8188       };
8189     } catch (std::exception& e) {
8190       {
8191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8192       };
8193     } catch (Dali::DaliException e) {
8194       {
8195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8196       };
8197     } catch (...) {
8198       {
8199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8200       };
8201     }
8202   }
8203
8204   jresult = *result;
8205   return jresult;
8206 }
8207
8208
8209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8210   float jresult ;
8211   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8212   Dali::Vector3 *arg2 = 0 ;
8213   float result;
8214
8215   arg1 = (Dali::Vector4 *)jarg1;
8216   arg2 = (Dali::Vector3 *)jarg2;
8217   if (!arg2) {
8218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8219     return 0;
8220   }
8221   {
8222     try {
8223       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8224     } catch (std::out_of_range& e) {
8225       {
8226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8227       };
8228     } catch (std::exception& e) {
8229       {
8230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8231       };
8232     } catch (Dali::DaliException e) {
8233       {
8234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8235       };
8236     } catch (...) {
8237       {
8238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8239       };
8240     }
8241   }
8242
8243   jresult = result;
8244   return jresult;
8245 }
8246
8247
8248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8249   float jresult ;
8250   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8251   Dali::Vector4 *arg2 = 0 ;
8252   float result;
8253
8254   arg1 = (Dali::Vector4 *)jarg1;
8255   arg2 = (Dali::Vector4 *)jarg2;
8256   if (!arg2) {
8257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8258     return 0;
8259   }
8260   {
8261     try {
8262       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8263     } catch (std::out_of_range& e) {
8264       {
8265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8266       };
8267     } catch (std::exception& e) {
8268       {
8269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8270       };
8271     } catch (Dali::DaliException e) {
8272       {
8273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8274       };
8275     } catch (...) {
8276       {
8277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8278       };
8279     }
8280   }
8281
8282   jresult = result;
8283   return jresult;
8284 }
8285
8286
8287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8288   float jresult ;
8289   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8290   Dali::Vector4 *arg2 = 0 ;
8291   float result;
8292
8293   arg1 = (Dali::Vector4 *)jarg1;
8294   arg2 = (Dali::Vector4 *)jarg2;
8295   if (!arg2) {
8296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8297     return 0;
8298   }
8299   {
8300     try {
8301       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8302     } catch (std::out_of_range& e) {
8303       {
8304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8305       };
8306     } catch (std::exception& e) {
8307       {
8308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8309       };
8310     } catch (Dali::DaliException e) {
8311       {
8312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8313       };
8314     } catch (...) {
8315       {
8316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8317       };
8318     }
8319   }
8320
8321   jresult = result;
8322   return jresult;
8323 }
8324
8325
8326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8327   void * jresult ;
8328   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8329   Dali::Vector4 *arg2 = 0 ;
8330   Dali::Vector4 result;
8331
8332   arg1 = (Dali::Vector4 *)jarg1;
8333   arg2 = (Dali::Vector4 *)jarg2;
8334   if (!arg2) {
8335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8336     return 0;
8337   }
8338   {
8339     try {
8340       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8341     } catch (std::out_of_range& e) {
8342       {
8343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8344       };
8345     } catch (std::exception& e) {
8346       {
8347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8348       };
8349     } catch (Dali::DaliException e) {
8350       {
8351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8352       };
8353     } catch (...) {
8354       {
8355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8356       };
8357     }
8358   }
8359
8360   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8361   return jresult;
8362 }
8363
8364
8365 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8366   float jresult ;
8367   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8368   float result;
8369
8370   arg1 = (Dali::Vector4 *)jarg1;
8371   {
8372     try {
8373       result = (float)((Dali::Vector4 const *)arg1)->Length();
8374     } catch (std::out_of_range& e) {
8375       {
8376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8377       };
8378     } catch (std::exception& e) {
8379       {
8380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8381       };
8382     } catch (Dali::DaliException e) {
8383       {
8384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8385       };
8386     } catch (...) {
8387       {
8388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8389       };
8390     }
8391   }
8392
8393   jresult = result;
8394   return jresult;
8395 }
8396
8397
8398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8399   float jresult ;
8400   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8401   float result;
8402
8403   arg1 = (Dali::Vector4 *)jarg1;
8404   {
8405     try {
8406       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8407     } catch (std::out_of_range& e) {
8408       {
8409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8410       };
8411     } catch (std::exception& e) {
8412       {
8413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8414       };
8415     } catch (Dali::DaliException e) {
8416       {
8417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8418       };
8419     } catch (...) {
8420       {
8421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8422       };
8423     }
8424   }
8425
8426   jresult = result;
8427   return jresult;
8428 }
8429
8430
8431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8432   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8433
8434   arg1 = (Dali::Vector4 *)jarg1;
8435   {
8436     try {
8437       (arg1)->Normalize();
8438     } catch (std::out_of_range& e) {
8439       {
8440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8441       };
8442     } catch (std::exception& e) {
8443       {
8444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8445       };
8446     } catch (Dali::DaliException e) {
8447       {
8448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8449       };
8450     } catch (...) {
8451       {
8452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8453       };
8454     }
8455   }
8456
8457 }
8458
8459
8460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8461   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8462   Dali::Vector4 *arg2 = 0 ;
8463   Dali::Vector4 *arg3 = 0 ;
8464
8465   arg1 = (Dali::Vector4 *)jarg1;
8466   arg2 = (Dali::Vector4 *)jarg2;
8467   if (!arg2) {
8468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8469     return ;
8470   }
8471   arg3 = (Dali::Vector4 *)jarg3;
8472   if (!arg3) {
8473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8474     return ;
8475   }
8476   {
8477     try {
8478       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8479     } catch (std::out_of_range& e) {
8480       {
8481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8482       };
8483     } catch (std::exception& e) {
8484       {
8485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8486       };
8487     } catch (Dali::DaliException e) {
8488       {
8489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8490       };
8491     } catch (...) {
8492       {
8493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8494       };
8495     }
8496   }
8497
8498 }
8499
8500
8501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8502   void * jresult ;
8503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8504   float *result = 0 ;
8505
8506   arg1 = (Dali::Vector4 *)jarg1;
8507   {
8508     try {
8509       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8510     } catch (std::out_of_range& e) {
8511       {
8512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8513       };
8514     } catch (std::exception& e) {
8515       {
8516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8517       };
8518     } catch (Dali::DaliException e) {
8519       {
8520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8521       };
8522     } catch (...) {
8523       {
8524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8525       };
8526     }
8527   }
8528
8529   jresult = (void *)result;
8530   return jresult;
8531 }
8532
8533
8534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8535   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8536   float arg2 ;
8537
8538   arg1 = (Dali::Vector4 *)jarg1;
8539   arg2 = (float)jarg2;
8540   if (arg1) (arg1)->x = arg2;
8541 }
8542
8543
8544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8545   float jresult ;
8546   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8547   float result;
8548
8549   arg1 = (Dali::Vector4 *)jarg1;
8550   result = (float) ((arg1)->x);
8551   jresult = result;
8552   return jresult;
8553 }
8554
8555
8556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8557   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8558   float arg2 ;
8559
8560   arg1 = (Dali::Vector4 *)jarg1;
8561   arg2 = (float)jarg2;
8562   if (arg1) (arg1)->r = arg2;
8563 }
8564
8565
8566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8567   float jresult ;
8568   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8569   float result;
8570
8571   arg1 = (Dali::Vector4 *)jarg1;
8572   result = (float) ((arg1)->r);
8573   jresult = result;
8574   return jresult;
8575 }
8576
8577
8578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8580   float arg2 ;
8581
8582   arg1 = (Dali::Vector4 *)jarg1;
8583   arg2 = (float)jarg2;
8584   if (arg1) (arg1)->s = arg2;
8585 }
8586
8587
8588 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8589   float jresult ;
8590   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8591   float result;
8592
8593   arg1 = (Dali::Vector4 *)jarg1;
8594   result = (float) ((arg1)->s);
8595   jresult = result;
8596   return jresult;
8597 }
8598
8599
8600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8601   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8602   float arg2 ;
8603
8604   arg1 = (Dali::Vector4 *)jarg1;
8605   arg2 = (float)jarg2;
8606   if (arg1) (arg1)->y = arg2;
8607 }
8608
8609
8610 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8611   float jresult ;
8612   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8613   float result;
8614
8615   arg1 = (Dali::Vector4 *)jarg1;
8616   result = (float) ((arg1)->y);
8617   jresult = result;
8618   return jresult;
8619 }
8620
8621
8622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8623   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8624   float arg2 ;
8625
8626   arg1 = (Dali::Vector4 *)jarg1;
8627   arg2 = (float)jarg2;
8628   if (arg1) (arg1)->g = arg2;
8629 }
8630
8631
8632 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8633   float jresult ;
8634   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8635   float result;
8636
8637   arg1 = (Dali::Vector4 *)jarg1;
8638   result = (float) ((arg1)->g);
8639   jresult = result;
8640   return jresult;
8641 }
8642
8643
8644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8645   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8646   float arg2 ;
8647
8648   arg1 = (Dali::Vector4 *)jarg1;
8649   arg2 = (float)jarg2;
8650   if (arg1) (arg1)->t = arg2;
8651 }
8652
8653
8654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8655   float jresult ;
8656   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8657   float result;
8658
8659   arg1 = (Dali::Vector4 *)jarg1;
8660   result = (float) ((arg1)->t);
8661   jresult = result;
8662   return jresult;
8663 }
8664
8665
8666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8667   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8668   float arg2 ;
8669
8670   arg1 = (Dali::Vector4 *)jarg1;
8671   arg2 = (float)jarg2;
8672   if (arg1) (arg1)->z = arg2;
8673 }
8674
8675
8676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8677   float jresult ;
8678   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8679   float result;
8680
8681   arg1 = (Dali::Vector4 *)jarg1;
8682   result = (float) ((arg1)->z);
8683   jresult = result;
8684   return jresult;
8685 }
8686
8687
8688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8690   float arg2 ;
8691
8692   arg1 = (Dali::Vector4 *)jarg1;
8693   arg2 = (float)jarg2;
8694   if (arg1) (arg1)->b = arg2;
8695 }
8696
8697
8698 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8699   float jresult ;
8700   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8701   float result;
8702
8703   arg1 = (Dali::Vector4 *)jarg1;
8704   result = (float) ((arg1)->b);
8705   jresult = result;
8706   return jresult;
8707 }
8708
8709
8710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8711   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8712   float arg2 ;
8713
8714   arg1 = (Dali::Vector4 *)jarg1;
8715   arg2 = (float)jarg2;
8716   if (arg1) (arg1)->p = arg2;
8717 }
8718
8719
8720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8721   float jresult ;
8722   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8723   float result;
8724
8725   arg1 = (Dali::Vector4 *)jarg1;
8726   result = (float) ((arg1)->p);
8727   jresult = result;
8728   return jresult;
8729 }
8730
8731
8732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8733   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8734   float arg2 ;
8735
8736   arg1 = (Dali::Vector4 *)jarg1;
8737   arg2 = (float)jarg2;
8738   if (arg1) (arg1)->w = arg2;
8739 }
8740
8741
8742 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8743   float jresult ;
8744   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8745   float result;
8746
8747   arg1 = (Dali::Vector4 *)jarg1;
8748   result = (float) ((arg1)->w);
8749   jresult = result;
8750   return jresult;
8751 }
8752
8753
8754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8755   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8756   float arg2 ;
8757
8758   arg1 = (Dali::Vector4 *)jarg1;
8759   arg2 = (float)jarg2;
8760   if (arg1) (arg1)->a = arg2;
8761 }
8762
8763
8764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8765   float jresult ;
8766   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8767   float result;
8768
8769   arg1 = (Dali::Vector4 *)jarg1;
8770   result = (float) ((arg1)->a);
8771   jresult = result;
8772   return jresult;
8773 }
8774
8775
8776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8777   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8778   float arg2 ;
8779
8780   arg1 = (Dali::Vector4 *)jarg1;
8781   arg2 = (float)jarg2;
8782   if (arg1) (arg1)->q = arg2;
8783 }
8784
8785
8786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8787   float jresult ;
8788   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8789   float result;
8790
8791   arg1 = (Dali::Vector4 *)jarg1;
8792   result = (float) ((arg1)->q);
8793   jresult = result;
8794   return jresult;
8795 }
8796
8797
8798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8799   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8800
8801   arg1 = (Dali::Vector4 *)jarg1;
8802   {
8803     try {
8804       delete arg1;
8805     } catch (std::out_of_range& e) {
8806       {
8807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8808       };
8809     } catch (std::exception& e) {
8810       {
8811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8812       };
8813     } catch (Dali::DaliException e) {
8814       {
8815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8816       };
8817     } catch (...) {
8818       {
8819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8820       };
8821     }
8822   }
8823
8824 }
8825
8826
8827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8828   void * jresult ;
8829   Dali::Vector4 *arg1 = 0 ;
8830   Dali::Vector4 *arg2 = 0 ;
8831   Dali::Vector4 result;
8832
8833   arg1 = (Dali::Vector4 *)jarg1;
8834   if (!arg1) {
8835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8836     return 0;
8837   }
8838   arg2 = (Dali::Vector4 *)jarg2;
8839   if (!arg2) {
8840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8841     return 0;
8842   }
8843   {
8844     try {
8845       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8846     } catch (std::out_of_range& e) {
8847       {
8848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8849       };
8850     } catch (std::exception& e) {
8851       {
8852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8853       };
8854     } catch (Dali::DaliException e) {
8855       {
8856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8857       };
8858     } catch (...) {
8859       {
8860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8861       };
8862     }
8863   }
8864
8865   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8866   return jresult;
8867 }
8868
8869
8870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8871   void * jresult ;
8872   Dali::Vector4 *arg1 = 0 ;
8873   Dali::Vector4 *arg2 = 0 ;
8874   Dali::Vector4 result;
8875
8876   arg1 = (Dali::Vector4 *)jarg1;
8877   if (!arg1) {
8878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8879     return 0;
8880   }
8881   arg2 = (Dali::Vector4 *)jarg2;
8882   if (!arg2) {
8883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8884     return 0;
8885   }
8886   {
8887     try {
8888       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8889     } catch (std::out_of_range& e) {
8890       {
8891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8892       };
8893     } catch (std::exception& e) {
8894       {
8895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8896       };
8897     } catch (Dali::DaliException e) {
8898       {
8899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8900       };
8901     } catch (...) {
8902       {
8903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8904       };
8905     }
8906   }
8907
8908   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8909   return jresult;
8910 }
8911
8912
8913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8914   void * jresult ;
8915   Dali::Vector4 *arg1 = 0 ;
8916   float *arg2 = 0 ;
8917   float *arg3 = 0 ;
8918   float temp2 ;
8919   float temp3 ;
8920   Dali::Vector4 result;
8921
8922   arg1 = (Dali::Vector4 *)jarg1;
8923   if (!arg1) {
8924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8925     return 0;
8926   }
8927   temp2 = (float)jarg2;
8928   arg2 = &temp2;
8929   temp3 = (float)jarg3;
8930   arg3 = &temp3;
8931   {
8932     try {
8933       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8934     } catch (std::out_of_range& e) {
8935       {
8936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8937       };
8938     } catch (std::exception& e) {
8939       {
8940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8941       };
8942     } catch (Dali::DaliException e) {
8943       {
8944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8945       };
8946     } catch (...) {
8947       {
8948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8949       };
8950     }
8951   }
8952
8953   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8954   return jresult;
8955 }
8956
8957
8958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8959   void * jresult ;
8960   Dali::Uint16Pair *result = 0 ;
8961
8962   {
8963     try {
8964       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8965     } catch (std::out_of_range& e) {
8966       {
8967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8968       };
8969     } catch (std::exception& e) {
8970       {
8971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8972       };
8973     } catch (Dali::DaliException e) {
8974       {
8975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8976       };
8977     } catch (...) {
8978       {
8979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8980       };
8981     }
8982   }
8983
8984   jresult = (void *)result;
8985   return jresult;
8986 }
8987
8988
8989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8990   void * jresult ;
8991   uint32_t arg1 ;
8992   uint32_t arg2 ;
8993   Dali::Uint16Pair *result = 0 ;
8994
8995   arg1 = (uint32_t)jarg1;
8996   arg2 = (uint32_t)jarg2;
8997   {
8998     try {
8999       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9000     } catch (std::out_of_range& e) {
9001       {
9002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9003       };
9004     } catch (std::exception& e) {
9005       {
9006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9007       };
9008     } catch (Dali::DaliException e) {
9009       {
9010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9011       };
9012     } catch (...) {
9013       {
9014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9015       };
9016     }
9017   }
9018
9019   jresult = (void *)result;
9020   return jresult;
9021 }
9022
9023
9024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9025   void * jresult ;
9026   Dali::Uint16Pair *arg1 = 0 ;
9027   Dali::Uint16Pair *result = 0 ;
9028
9029   arg1 = (Dali::Uint16Pair *)jarg1;
9030   if (!arg1) {
9031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9032     return 0;
9033   }
9034   {
9035     try {
9036       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9037     } catch (std::out_of_range& e) {
9038       {
9039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9040       };
9041     } catch (std::exception& e) {
9042       {
9043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9044       };
9045     } catch (Dali::DaliException e) {
9046       {
9047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9048       };
9049     } catch (...) {
9050       {
9051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9052       };
9053     }
9054   }
9055
9056   jresult = (void *)result;
9057   return jresult;
9058 }
9059
9060
9061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9062   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9063   uint16_t arg2 ;
9064
9065   arg1 = (Dali::Uint16Pair *)jarg1;
9066   arg2 = (uint16_t)jarg2;
9067   {
9068     try {
9069       (arg1)->SetWidth(arg2);
9070     } catch (std::out_of_range& e) {
9071       {
9072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9073       };
9074     } catch (std::exception& e) {
9075       {
9076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9077       };
9078     } catch (Dali::DaliException e) {
9079       {
9080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9081       };
9082     } catch (...) {
9083       {
9084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9085       };
9086     }
9087   }
9088
9089 }
9090
9091
9092 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9093   unsigned short jresult ;
9094   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9095   uint16_t result;
9096
9097   arg1 = (Dali::Uint16Pair *)jarg1;
9098   {
9099     try {
9100       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9101     } catch (std::out_of_range& e) {
9102       {
9103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9104       };
9105     } catch (std::exception& e) {
9106       {
9107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9108       };
9109     } catch (Dali::DaliException e) {
9110       {
9111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9112       };
9113     } catch (...) {
9114       {
9115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9116       };
9117     }
9118   }
9119
9120   jresult = result;
9121   return jresult;
9122 }
9123
9124
9125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9126   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9127   uint16_t arg2 ;
9128
9129   arg1 = (Dali::Uint16Pair *)jarg1;
9130   arg2 = (uint16_t)jarg2;
9131   {
9132     try {
9133       (arg1)->SetHeight(arg2);
9134     } catch (std::out_of_range& e) {
9135       {
9136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9137       };
9138     } catch (std::exception& e) {
9139       {
9140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9141       };
9142     } catch (Dali::DaliException e) {
9143       {
9144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9145       };
9146     } catch (...) {
9147       {
9148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9149       };
9150     }
9151   }
9152
9153 }
9154
9155
9156 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9157   unsigned short jresult ;
9158   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9159   uint16_t result;
9160
9161   arg1 = (Dali::Uint16Pair *)jarg1;
9162   {
9163     try {
9164       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9165     } catch (std::out_of_range& e) {
9166       {
9167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9168       };
9169     } catch (std::exception& e) {
9170       {
9171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9172       };
9173     } catch (Dali::DaliException e) {
9174       {
9175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9176       };
9177     } catch (...) {
9178       {
9179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9180       };
9181     }
9182   }
9183
9184   jresult = result;
9185   return jresult;
9186 }
9187
9188
9189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9190   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9191   uint16_t arg2 ;
9192
9193   arg1 = (Dali::Uint16Pair *)jarg1;
9194   arg2 = (uint16_t)jarg2;
9195   {
9196     try {
9197       (arg1)->SetX(arg2);
9198     } catch (std::out_of_range& e) {
9199       {
9200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9201       };
9202     } catch (std::exception& e) {
9203       {
9204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9205       };
9206     } catch (Dali::DaliException e) {
9207       {
9208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9209       };
9210     } catch (...) {
9211       {
9212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9213       };
9214     }
9215   }
9216
9217 }
9218
9219
9220 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9221   unsigned short jresult ;
9222   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9223   uint16_t result;
9224
9225   arg1 = (Dali::Uint16Pair *)jarg1;
9226   {
9227     try {
9228       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9229     } catch (std::out_of_range& e) {
9230       {
9231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9232       };
9233     } catch (std::exception& e) {
9234       {
9235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9236       };
9237     } catch (Dali::DaliException e) {
9238       {
9239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9240       };
9241     } catch (...) {
9242       {
9243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9244       };
9245     }
9246   }
9247
9248   jresult = result;
9249   return jresult;
9250 }
9251
9252
9253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9254   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9255   uint16_t arg2 ;
9256
9257   arg1 = (Dali::Uint16Pair *)jarg1;
9258   arg2 = (uint16_t)jarg2;
9259   {
9260     try {
9261       (arg1)->SetY(arg2);
9262     } catch (std::out_of_range& e) {
9263       {
9264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9265       };
9266     } catch (std::exception& e) {
9267       {
9268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9269       };
9270     } catch (Dali::DaliException e) {
9271       {
9272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9273       };
9274     } catch (...) {
9275       {
9276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9277       };
9278     }
9279   }
9280
9281 }
9282
9283
9284 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9285   unsigned short jresult ;
9286   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9287   uint16_t result;
9288
9289   arg1 = (Dali::Uint16Pair *)jarg1;
9290   {
9291     try {
9292       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9293     } catch (std::out_of_range& e) {
9294       {
9295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9296       };
9297     } catch (std::exception& e) {
9298       {
9299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9300       };
9301     } catch (Dali::DaliException e) {
9302       {
9303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9304       };
9305     } catch (...) {
9306       {
9307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9308       };
9309     }
9310   }
9311
9312   jresult = result;
9313   return jresult;
9314 }
9315
9316
9317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9318   void * jresult ;
9319   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9320   Dali::Uint16Pair *arg2 = 0 ;
9321   Dali::Uint16Pair *result = 0 ;
9322
9323   arg1 = (Dali::Uint16Pair *)jarg1;
9324   arg2 = (Dali::Uint16Pair *)jarg2;
9325   if (!arg2) {
9326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9327     return 0;
9328   }
9329   {
9330     try {
9331       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9332     } catch (std::out_of_range& e) {
9333       {
9334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9335       };
9336     } catch (std::exception& e) {
9337       {
9338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9339       };
9340     } catch (Dali::DaliException e) {
9341       {
9342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9343       };
9344     } catch (...) {
9345       {
9346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9347       };
9348     }
9349   }
9350
9351   jresult = (void *)result;
9352   return jresult;
9353 }
9354
9355
9356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9357   unsigned int jresult ;
9358   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9359   Dali::Uint16Pair *arg2 = 0 ;
9360   bool result;
9361
9362   arg1 = (Dali::Uint16Pair *)jarg1;
9363   arg2 = (Dali::Uint16Pair *)jarg2;
9364   if (!arg2) {
9365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9366     return 0;
9367   }
9368   {
9369     try {
9370       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9371     } catch (std::out_of_range& e) {
9372       {
9373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9374       };
9375     } catch (std::exception& e) {
9376       {
9377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9378       };
9379     } catch (Dali::DaliException e) {
9380       {
9381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9382       };
9383     } catch (...) {
9384       {
9385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9386       };
9387     }
9388   }
9389
9390   jresult = result;
9391   return jresult;
9392 }
9393
9394
9395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9396   unsigned int jresult ;
9397   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9398   Dali::Uint16Pair *arg2 = 0 ;
9399   bool result;
9400
9401   arg1 = (Dali::Uint16Pair *)jarg1;
9402   arg2 = (Dali::Uint16Pair *)jarg2;
9403   if (!arg2) {
9404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9405     return 0;
9406   }
9407   {
9408     try {
9409       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9410     } catch (std::out_of_range& e) {
9411       {
9412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9413       };
9414     } catch (std::exception& e) {
9415       {
9416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9417       };
9418     } catch (Dali::DaliException e) {
9419       {
9420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9421       };
9422     } catch (...) {
9423       {
9424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9425       };
9426     }
9427   }
9428
9429   jresult = result;
9430   return jresult;
9431 }
9432
9433
9434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9435   unsigned int jresult ;
9436   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9437   Dali::Uint16Pair *arg2 = 0 ;
9438   bool result;
9439
9440   arg1 = (Dali::Uint16Pair *)jarg1;
9441   arg2 = (Dali::Uint16Pair *)jarg2;
9442   if (!arg2) {
9443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9444     return 0;
9445   }
9446   {
9447     try {
9448       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9449     } catch (std::out_of_range& e) {
9450       {
9451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9452       };
9453     } catch (std::exception& e) {
9454       {
9455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9456       };
9457     } catch (Dali::DaliException e) {
9458       {
9459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9460       };
9461     } catch (...) {
9462       {
9463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9464       };
9465     }
9466   }
9467
9468   jresult = result;
9469   return jresult;
9470 }
9471
9472
9473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9474   unsigned int jresult ;
9475   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9476   Dali::Uint16Pair *arg2 = 0 ;
9477   bool result;
9478
9479   arg1 = (Dali::Uint16Pair *)jarg1;
9480   arg2 = (Dali::Uint16Pair *)jarg2;
9481   if (!arg2) {
9482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9483     return 0;
9484   }
9485   {
9486     try {
9487       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9488     } catch (std::out_of_range& e) {
9489       {
9490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9491       };
9492     } catch (std::exception& e) {
9493       {
9494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9495       };
9496     } catch (Dali::DaliException e) {
9497       {
9498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9499       };
9500     } catch (...) {
9501       {
9502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9503       };
9504     }
9505   }
9506
9507   jresult = result;
9508   return jresult;
9509 }
9510
9511
9512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9513   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9514
9515   arg1 = (Dali::Uint16Pair *)jarg1;
9516   {
9517     try {
9518       delete arg1;
9519     } catch (std::out_of_range& e) {
9520       {
9521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9522       };
9523     } catch (std::exception& e) {
9524       {
9525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9526       };
9527     } catch (Dali::DaliException e) {
9528       {
9529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9530       };
9531     } catch (...) {
9532       {
9533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9534       };
9535     }
9536   }
9537
9538 }
9539
9540
9541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9542   void * jresult ;
9543   Dali::Degree *result = 0 ;
9544
9545   {
9546     try {
9547       result = (Dali::Degree *)new Dali::Degree();
9548     } catch (std::out_of_range& e) {
9549       {
9550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9551       };
9552     } catch (std::exception& e) {
9553       {
9554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9555       };
9556     } catch (Dali::DaliException e) {
9557       {
9558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9559       };
9560     } catch (...) {
9561       {
9562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9563       };
9564     }
9565   }
9566
9567   jresult = (void *)result;
9568   return jresult;
9569 }
9570
9571
9572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9573   void * jresult ;
9574   float arg1 ;
9575   Dali::Degree *result = 0 ;
9576
9577   arg1 = (float)jarg1;
9578   {
9579     try {
9580       result = (Dali::Degree *)new Dali::Degree(arg1);
9581     } catch (std::out_of_range& e) {
9582       {
9583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9584       };
9585     } catch (std::exception& e) {
9586       {
9587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9588       };
9589     } catch (Dali::DaliException e) {
9590       {
9591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9592       };
9593     } catch (...) {
9594       {
9595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9596       };
9597     }
9598   }
9599
9600   jresult = (void *)result;
9601   return jresult;
9602 }
9603
9604
9605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9606   void * jresult ;
9607   Dali::Radian arg1 ;
9608   Dali::Radian *argp1 ;
9609   Dali::Degree *result = 0 ;
9610
9611   argp1 = (Dali::Radian *)jarg1;
9612   if (!argp1) {
9613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9614     return 0;
9615   }
9616   arg1 = *argp1;
9617   {
9618     try {
9619       result = (Dali::Degree *)new Dali::Degree(arg1);
9620     } catch (std::out_of_range& e) {
9621       {
9622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9623       };
9624     } catch (std::exception& e) {
9625       {
9626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9627       };
9628     } catch (Dali::DaliException e) {
9629       {
9630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9631       };
9632     } catch (...) {
9633       {
9634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9635       };
9636     }
9637   }
9638
9639   jresult = (void *)result;
9640   return jresult;
9641 }
9642
9643
9644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9645   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9646   float arg2 ;
9647
9648   arg1 = (Dali::Degree *)jarg1;
9649   arg2 = (float)jarg2;
9650   if (arg1) (arg1)->degree = arg2;
9651 }
9652
9653
9654 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9655   float jresult ;
9656   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9657   float result;
9658
9659   arg1 = (Dali::Degree *)jarg1;
9660   result = (float) ((arg1)->degree);
9661   jresult = result;
9662   return jresult;
9663 }
9664
9665
9666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9667   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9668
9669   arg1 = (Dali::Degree *)jarg1;
9670   {
9671     try {
9672       delete arg1;
9673     } catch (std::out_of_range& e) {
9674       {
9675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9676       };
9677     } catch (std::exception& e) {
9678       {
9679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9680       };
9681     } catch (Dali::DaliException e) {
9682       {
9683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9684       };
9685     } catch (...) {
9686       {
9687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9688       };
9689     }
9690   }
9691
9692 }
9693
9694
9695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9696   void * jresult ;
9697   Dali::Radian *result = 0 ;
9698
9699   result = (Dali::Radian *)&Dali::ANGLE_360;
9700   jresult = (void *)result;
9701   return jresult;
9702 }
9703
9704
9705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9706   void * jresult ;
9707   Dali::Radian *result = 0 ;
9708
9709   result = (Dali::Radian *)&Dali::ANGLE_315;
9710   jresult = (void *)result;
9711   return jresult;
9712 }
9713
9714
9715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9716   void * jresult ;
9717   Dali::Radian *result = 0 ;
9718
9719   result = (Dali::Radian *)&Dali::ANGLE_270;
9720   jresult = (void *)result;
9721   return jresult;
9722 }
9723
9724
9725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9726   void * jresult ;
9727   Dali::Radian *result = 0 ;
9728
9729   result = (Dali::Radian *)&Dali::ANGLE_225;
9730   jresult = (void *)result;
9731   return jresult;
9732 }
9733
9734
9735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9736   void * jresult ;
9737   Dali::Radian *result = 0 ;
9738
9739   result = (Dali::Radian *)&Dali::ANGLE_180;
9740   jresult = (void *)result;
9741   return jresult;
9742 }
9743
9744
9745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9746   void * jresult ;
9747   Dali::Radian *result = 0 ;
9748
9749   result = (Dali::Radian *)&Dali::ANGLE_135;
9750   jresult = (void *)result;
9751   return jresult;
9752 }
9753
9754
9755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9756   void * jresult ;
9757   Dali::Radian *result = 0 ;
9758
9759   result = (Dali::Radian *)&Dali::ANGLE_120;
9760   jresult = (void *)result;
9761   return jresult;
9762 }
9763
9764
9765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9766   void * jresult ;
9767   Dali::Radian *result = 0 ;
9768
9769   result = (Dali::Radian *)&Dali::ANGLE_90;
9770   jresult = (void *)result;
9771   return jresult;
9772 }
9773
9774
9775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9776   void * jresult ;
9777   Dali::Radian *result = 0 ;
9778
9779   result = (Dali::Radian *)&Dali::ANGLE_60;
9780   jresult = (void *)result;
9781   return jresult;
9782 }
9783
9784
9785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9786   void * jresult ;
9787   Dali::Radian *result = 0 ;
9788
9789   result = (Dali::Radian *)&Dali::ANGLE_45;
9790   jresult = (void *)result;
9791   return jresult;
9792 }
9793
9794
9795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9796   void * jresult ;
9797   Dali::Radian *result = 0 ;
9798
9799   result = (Dali::Radian *)&Dali::ANGLE_30;
9800   jresult = (void *)result;
9801   return jresult;
9802 }
9803
9804
9805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9806   void * jresult ;
9807   Dali::Radian *result = 0 ;
9808
9809   result = (Dali::Radian *)&Dali::ANGLE_0;
9810   jresult = (void *)result;
9811   return jresult;
9812 }
9813
9814
9815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9816   unsigned int jresult ;
9817   Dali::Degree *arg1 = 0 ;
9818   Dali::Degree *arg2 = 0 ;
9819   bool result;
9820
9821   arg1 = (Dali::Degree *)jarg1;
9822   if (!arg1) {
9823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9824     return 0;
9825   }
9826   arg2 = (Dali::Degree *)jarg2;
9827   if (!arg2) {
9828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9829     return 0;
9830   }
9831   {
9832     try {
9833       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9834     } catch (std::out_of_range& e) {
9835       {
9836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9837       };
9838     } catch (std::exception& e) {
9839       {
9840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9841       };
9842     } catch (Dali::DaliException e) {
9843       {
9844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9845       };
9846     } catch (...) {
9847       {
9848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9849       };
9850     }
9851   }
9852
9853   jresult = result;
9854   return jresult;
9855 }
9856
9857
9858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9859   unsigned int jresult ;
9860   Dali::Degree *arg1 = 0 ;
9861   Dali::Degree *arg2 = 0 ;
9862   bool result;
9863
9864   arg1 = (Dali::Degree *)jarg1;
9865   if (!arg1) {
9866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9867     return 0;
9868   }
9869   arg2 = (Dali::Degree *)jarg2;
9870   if (!arg2) {
9871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9872     return 0;
9873   }
9874   {
9875     try {
9876       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9877     } catch (std::out_of_range& e) {
9878       {
9879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9880       };
9881     } catch (std::exception& e) {
9882       {
9883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9884       };
9885     } catch (Dali::DaliException e) {
9886       {
9887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9888       };
9889     } catch (...) {
9890       {
9891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9892       };
9893     }
9894   }
9895
9896   jresult = result;
9897   return jresult;
9898 }
9899
9900
9901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9902   void * jresult ;
9903   Dali::Degree arg1 ;
9904   float arg2 ;
9905   float arg3 ;
9906   Dali::Degree *argp1 ;
9907   Dali::Degree result;
9908
9909   argp1 = (Dali::Degree *)jarg1;
9910   if (!argp1) {
9911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9912     return 0;
9913   }
9914   arg1 = *argp1;
9915   arg2 = (float)jarg2;
9916   arg3 = (float)jarg3;
9917   {
9918     try {
9919       result = Dali::Clamp(arg1,arg2,arg3);
9920     } catch (std::out_of_range& e) {
9921       {
9922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9923       };
9924     } catch (std::exception& e) {
9925       {
9926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9927       };
9928     } catch (Dali::DaliException e) {
9929       {
9930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9931       };
9932     } catch (...) {
9933       {
9934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9935       };
9936     }
9937   }
9938
9939   jresult = new Dali::Degree((const Dali::Degree &)result);
9940   return jresult;
9941 }
9942
9943
9944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9945   void * jresult ;
9946   Dali::Radian *result = 0 ;
9947
9948   {
9949     try {
9950       result = (Dali::Radian *)new Dali::Radian();
9951     } catch (std::out_of_range& e) {
9952       {
9953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9954       };
9955     } catch (std::exception& e) {
9956       {
9957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9958       };
9959     } catch (Dali::DaliException e) {
9960       {
9961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9962       };
9963     } catch (...) {
9964       {
9965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9966       };
9967     }
9968   }
9969
9970   jresult = (void *)result;
9971   return jresult;
9972 }
9973
9974
9975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9976   void * jresult ;
9977   float arg1 ;
9978   Dali::Radian *result = 0 ;
9979
9980   arg1 = (float)jarg1;
9981   {
9982     try {
9983       result = (Dali::Radian *)new Dali::Radian(arg1);
9984     } catch (std::out_of_range& e) {
9985       {
9986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9987       };
9988     } catch (std::exception& e) {
9989       {
9990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9991       };
9992     } catch (Dali::DaliException e) {
9993       {
9994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9995       };
9996     } catch (...) {
9997       {
9998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9999       };
10000     }
10001   }
10002
10003   jresult = (void *)result;
10004   return jresult;
10005 }
10006
10007
10008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10009   void * jresult ;
10010   Dali::Degree arg1 ;
10011   Dali::Degree *argp1 ;
10012   Dali::Radian *result = 0 ;
10013
10014   argp1 = (Dali::Degree *)jarg1;
10015   if (!argp1) {
10016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10017     return 0;
10018   }
10019   arg1 = *argp1;
10020   {
10021     try {
10022       result = (Dali::Radian *)new Dali::Radian(arg1);
10023     } catch (std::out_of_range& e) {
10024       {
10025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10026       };
10027     } catch (std::exception& e) {
10028       {
10029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10030       };
10031     } catch (Dali::DaliException e) {
10032       {
10033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10034       };
10035     } catch (...) {
10036       {
10037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10038       };
10039     }
10040   }
10041
10042   jresult = (void *)result;
10043   return jresult;
10044 }
10045
10046
10047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10048   void * jresult ;
10049   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10050   float arg2 ;
10051   Dali::Radian *result = 0 ;
10052
10053   arg1 = (Dali::Radian *)jarg1;
10054   arg2 = (float)jarg2;
10055   {
10056     try {
10057       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10058     } catch (std::out_of_range& e) {
10059       {
10060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10061       };
10062     } catch (std::exception& e) {
10063       {
10064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10065       };
10066     } catch (Dali::DaliException e) {
10067       {
10068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10069       };
10070     } catch (...) {
10071       {
10072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10073       };
10074     }
10075   }
10076
10077   jresult = (void *)result;
10078   return jresult;
10079 }
10080
10081
10082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10083   void * jresult ;
10084   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10085   Dali::Degree arg2 ;
10086   Dali::Degree *argp2 ;
10087   Dali::Radian *result = 0 ;
10088
10089   arg1 = (Dali::Radian *)jarg1;
10090   argp2 = (Dali::Degree *)jarg2;
10091   if (!argp2) {
10092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10093     return 0;
10094   }
10095   arg2 = *argp2;
10096   {
10097     try {
10098       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10099     } catch (std::out_of_range& e) {
10100       {
10101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10102       };
10103     } catch (std::exception& e) {
10104       {
10105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10106       };
10107     } catch (Dali::DaliException e) {
10108       {
10109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10110       };
10111     } catch (...) {
10112       {
10113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10114       };
10115     }
10116   }
10117
10118   jresult = (void *)result;
10119   return jresult;
10120 }
10121
10122
10123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10124   float jresult ;
10125   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10126   float result;
10127
10128   arg1 = (Dali::Radian *)jarg1;
10129   {
10130     try {
10131       result = (float)((Dali::Radian const *)arg1)->operator float();
10132     } catch (std::out_of_range& e) {
10133       {
10134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10135       };
10136     } catch (std::exception& e) {
10137       {
10138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10139       };
10140     } catch (Dali::DaliException e) {
10141       {
10142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10143       };
10144     } catch (...) {
10145       {
10146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10147       };
10148     }
10149   }
10150
10151   jresult = result;
10152   return jresult;
10153 }
10154
10155
10156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10157   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10158   float arg2 ;
10159
10160   arg1 = (Dali::Radian *)jarg1;
10161   arg2 = (float)jarg2;
10162   if (arg1) (arg1)->radian = arg2;
10163 }
10164
10165
10166 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10167   float jresult ;
10168   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10169   float result;
10170
10171   arg1 = (Dali::Radian *)jarg1;
10172   result = (float) ((arg1)->radian);
10173   jresult = result;
10174   return jresult;
10175 }
10176
10177
10178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10179   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10180
10181   arg1 = (Dali::Radian *)jarg1;
10182   {
10183     try {
10184       delete arg1;
10185     } catch (std::out_of_range& e) {
10186       {
10187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10188       };
10189     } catch (std::exception& e) {
10190       {
10191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10192       };
10193     } catch (Dali::DaliException e) {
10194       {
10195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10196       };
10197     } catch (...) {
10198       {
10199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10200       };
10201     }
10202   }
10203
10204 }
10205
10206
10207 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10208   unsigned int jresult ;
10209   Dali::Radian arg1 ;
10210   Dali::Radian arg2 ;
10211   Dali::Radian *argp1 ;
10212   Dali::Radian *argp2 ;
10213   bool result;
10214
10215   argp1 = (Dali::Radian *)jarg1;
10216   if (!argp1) {
10217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10218     return 0;
10219   }
10220   arg1 = *argp1;
10221   argp2 = (Dali::Radian *)jarg2;
10222   if (!argp2) {
10223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10224     return 0;
10225   }
10226   arg2 = *argp2;
10227   {
10228     try {
10229       result = (bool)Dali::operator ==(arg1,arg2);
10230     } catch (std::out_of_range& e) {
10231       {
10232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10233       };
10234     } catch (std::exception& e) {
10235       {
10236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10237       };
10238     } catch (Dali::DaliException e) {
10239       {
10240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10241       };
10242     } catch (...) {
10243       {
10244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10245       };
10246     }
10247   }
10248
10249   jresult = result;
10250   return jresult;
10251 }
10252
10253
10254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10255   unsigned int jresult ;
10256   Dali::Radian arg1 ;
10257   Dali::Radian arg2 ;
10258   Dali::Radian *argp1 ;
10259   Dali::Radian *argp2 ;
10260   bool result;
10261
10262   argp1 = (Dali::Radian *)jarg1;
10263   if (!argp1) {
10264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10265     return 0;
10266   }
10267   arg1 = *argp1;
10268   argp2 = (Dali::Radian *)jarg2;
10269   if (!argp2) {
10270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10271     return 0;
10272   }
10273   arg2 = *argp2;
10274   {
10275     try {
10276       result = (bool)Dali::operator !=(arg1,arg2);
10277     } catch (std::out_of_range& e) {
10278       {
10279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10280       };
10281     } catch (std::exception& e) {
10282       {
10283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10284       };
10285     } catch (Dali::DaliException e) {
10286       {
10287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10288       };
10289     } catch (...) {
10290       {
10291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10292       };
10293     }
10294   }
10295
10296   jresult = result;
10297   return jresult;
10298 }
10299
10300
10301 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10302   unsigned int jresult ;
10303   Dali::Radian arg1 ;
10304   Dali::Degree arg2 ;
10305   Dali::Radian *argp1 ;
10306   Dali::Degree *argp2 ;
10307   bool result;
10308
10309   argp1 = (Dali::Radian *)jarg1;
10310   if (!argp1) {
10311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10312     return 0;
10313   }
10314   arg1 = *argp1;
10315   argp2 = (Dali::Degree *)jarg2;
10316   if (!argp2) {
10317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10318     return 0;
10319   }
10320   arg2 = *argp2;
10321   {
10322     try {
10323       result = (bool)Dali::operator ==(arg1,arg2);
10324     } catch (std::out_of_range& e) {
10325       {
10326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10327       };
10328     } catch (std::exception& e) {
10329       {
10330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10331       };
10332     } catch (Dali::DaliException e) {
10333       {
10334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10335       };
10336     } catch (...) {
10337       {
10338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10339       };
10340     }
10341   }
10342
10343   jresult = result;
10344   return jresult;
10345 }
10346
10347
10348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10349   unsigned int jresult ;
10350   Dali::Radian arg1 ;
10351   Dali::Degree arg2 ;
10352   Dali::Radian *argp1 ;
10353   Dali::Degree *argp2 ;
10354   bool result;
10355
10356   argp1 = (Dali::Radian *)jarg1;
10357   if (!argp1) {
10358     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10359     return 0;
10360   }
10361   arg1 = *argp1;
10362   argp2 = (Dali::Degree *)jarg2;
10363   if (!argp2) {
10364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10365     return 0;
10366   }
10367   arg2 = *argp2;
10368   {
10369     try {
10370       result = (bool)Dali::operator !=(arg1,arg2);
10371     } catch (std::out_of_range& e) {
10372       {
10373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10374       };
10375     } catch (std::exception& e) {
10376       {
10377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10378       };
10379     } catch (Dali::DaliException e) {
10380       {
10381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10382       };
10383     } catch (...) {
10384       {
10385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10386       };
10387     }
10388   }
10389
10390   jresult = result;
10391   return jresult;
10392 }
10393
10394
10395 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10396   unsigned int jresult ;
10397   Dali::Degree arg1 ;
10398   Dali::Radian arg2 ;
10399   Dali::Degree *argp1 ;
10400   Dali::Radian *argp2 ;
10401   bool result;
10402
10403   argp1 = (Dali::Degree *)jarg1;
10404   if (!argp1) {
10405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10406     return 0;
10407   }
10408   arg1 = *argp1;
10409   argp2 = (Dali::Radian *)jarg2;
10410   if (!argp2) {
10411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10412     return 0;
10413   }
10414   arg2 = *argp2;
10415   {
10416     try {
10417       result = (bool)Dali::operator ==(arg1,arg2);
10418     } catch (std::out_of_range& e) {
10419       {
10420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10421       };
10422     } catch (std::exception& e) {
10423       {
10424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10425       };
10426     } catch (Dali::DaliException e) {
10427       {
10428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10429       };
10430     } catch (...) {
10431       {
10432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10433       };
10434     }
10435   }
10436
10437   jresult = result;
10438   return jresult;
10439 }
10440
10441
10442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10443   unsigned int jresult ;
10444   Dali::Degree arg1 ;
10445   Dali::Radian arg2 ;
10446   Dali::Degree *argp1 ;
10447   Dali::Radian *argp2 ;
10448   bool result;
10449
10450   argp1 = (Dali::Degree *)jarg1;
10451   if (!argp1) {
10452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10453     return 0;
10454   }
10455   arg1 = *argp1;
10456   argp2 = (Dali::Radian *)jarg2;
10457   if (!argp2) {
10458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10459     return 0;
10460   }
10461   arg2 = *argp2;
10462   {
10463     try {
10464       result = (bool)Dali::operator !=(arg1,arg2);
10465     } catch (std::out_of_range& e) {
10466       {
10467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10468       };
10469     } catch (std::exception& e) {
10470       {
10471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10472       };
10473     } catch (Dali::DaliException e) {
10474       {
10475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10476       };
10477     } catch (...) {
10478       {
10479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10480       };
10481     }
10482   }
10483
10484   jresult = result;
10485   return jresult;
10486 }
10487
10488
10489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10490   unsigned int jresult ;
10491   Dali::Radian arg1 ;
10492   Dali::Radian arg2 ;
10493   Dali::Radian *argp1 ;
10494   Dali::Radian *argp2 ;
10495   bool result;
10496
10497   argp1 = (Dali::Radian *)jarg1;
10498   if (!argp1) {
10499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10500     return 0;
10501   }
10502   arg1 = *argp1;
10503   argp2 = (Dali::Radian *)jarg2;
10504   if (!argp2) {
10505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10506     return 0;
10507   }
10508   arg2 = *argp2;
10509   {
10510     try {
10511       result = (bool)Dali::operator >(arg1,arg2);
10512     } catch (std::out_of_range& e) {
10513       {
10514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10515       };
10516     } catch (std::exception& e) {
10517       {
10518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10519       };
10520     } catch (Dali::DaliException e) {
10521       {
10522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10523       };
10524     } catch (...) {
10525       {
10526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10527       };
10528     }
10529   }
10530
10531   jresult = result;
10532   return jresult;
10533 }
10534
10535
10536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10537   unsigned int jresult ;
10538   Dali::Radian arg1 ;
10539   Dali::Degree arg2 ;
10540   Dali::Radian *argp1 ;
10541   Dali::Degree *argp2 ;
10542   bool result;
10543
10544   argp1 = (Dali::Radian *)jarg1;
10545   if (!argp1) {
10546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10547     return 0;
10548   }
10549   arg1 = *argp1;
10550   argp2 = (Dali::Degree *)jarg2;
10551   if (!argp2) {
10552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10553     return 0;
10554   }
10555   arg2 = *argp2;
10556   {
10557     try {
10558       result = (bool)Dali::operator >(arg1,arg2);
10559     } catch (std::out_of_range& e) {
10560       {
10561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10562       };
10563     } catch (std::exception& e) {
10564       {
10565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10566       };
10567     } catch (Dali::DaliException e) {
10568       {
10569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10570       };
10571     } catch (...) {
10572       {
10573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10574       };
10575     }
10576   }
10577
10578   jresult = result;
10579   return jresult;
10580 }
10581
10582
10583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10584   unsigned int jresult ;
10585   Dali::Degree arg1 ;
10586   Dali::Radian arg2 ;
10587   Dali::Degree *argp1 ;
10588   Dali::Radian *argp2 ;
10589   bool result;
10590
10591   argp1 = (Dali::Degree *)jarg1;
10592   if (!argp1) {
10593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10594     return 0;
10595   }
10596   arg1 = *argp1;
10597   argp2 = (Dali::Radian *)jarg2;
10598   if (!argp2) {
10599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10600     return 0;
10601   }
10602   arg2 = *argp2;
10603   {
10604     try {
10605       result = (bool)Dali::operator >(arg1,arg2);
10606     } catch (std::out_of_range& e) {
10607       {
10608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10609       };
10610     } catch (std::exception& e) {
10611       {
10612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10613       };
10614     } catch (Dali::DaliException e) {
10615       {
10616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10617       };
10618     } catch (...) {
10619       {
10620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10621       };
10622     }
10623   }
10624
10625   jresult = result;
10626   return jresult;
10627 }
10628
10629
10630 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10631   unsigned int jresult ;
10632   Dali::Radian arg1 ;
10633   Dali::Radian arg2 ;
10634   Dali::Radian *argp1 ;
10635   Dali::Radian *argp2 ;
10636   bool result;
10637
10638   argp1 = (Dali::Radian *)jarg1;
10639   if (!argp1) {
10640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10641     return 0;
10642   }
10643   arg1 = *argp1;
10644   argp2 = (Dali::Radian *)jarg2;
10645   if (!argp2) {
10646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10647     return 0;
10648   }
10649   arg2 = *argp2;
10650   {
10651     try {
10652       result = (bool)Dali::operator <(arg1,arg2);
10653     } catch (std::out_of_range& e) {
10654       {
10655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10656       };
10657     } catch (std::exception& e) {
10658       {
10659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10660       };
10661     } catch (Dali::DaliException e) {
10662       {
10663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10664       };
10665     } catch (...) {
10666       {
10667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10668       };
10669     }
10670   }
10671
10672   jresult = result;
10673   return jresult;
10674 }
10675
10676
10677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10678   unsigned int jresult ;
10679   Dali::Radian arg1 ;
10680   Dali::Degree arg2 ;
10681   Dali::Radian *argp1 ;
10682   Dali::Degree *argp2 ;
10683   bool result;
10684
10685   argp1 = (Dali::Radian *)jarg1;
10686   if (!argp1) {
10687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10688     return 0;
10689   }
10690   arg1 = *argp1;
10691   argp2 = (Dali::Degree *)jarg2;
10692   if (!argp2) {
10693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10694     return 0;
10695   }
10696   arg2 = *argp2;
10697   {
10698     try {
10699       result = (bool)Dali::operator <(arg1,arg2);
10700     } catch (std::out_of_range& e) {
10701       {
10702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10703       };
10704     } catch (std::exception& e) {
10705       {
10706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10707       };
10708     } catch (Dali::DaliException e) {
10709       {
10710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10711       };
10712     } catch (...) {
10713       {
10714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10715       };
10716     }
10717   }
10718
10719   jresult = result;
10720   return jresult;
10721 }
10722
10723
10724 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10725   unsigned int jresult ;
10726   Dali::Degree arg1 ;
10727   Dali::Radian arg2 ;
10728   Dali::Degree *argp1 ;
10729   Dali::Radian *argp2 ;
10730   bool result;
10731
10732   argp1 = (Dali::Degree *)jarg1;
10733   if (!argp1) {
10734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10735     return 0;
10736   }
10737   arg1 = *argp1;
10738   argp2 = (Dali::Radian *)jarg2;
10739   if (!argp2) {
10740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10741     return 0;
10742   }
10743   arg2 = *argp2;
10744   {
10745     try {
10746       result = (bool)Dali::operator <(arg1,arg2);
10747     } catch (std::out_of_range& e) {
10748       {
10749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10750       };
10751     } catch (std::exception& e) {
10752       {
10753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10754       };
10755     } catch (Dali::DaliException e) {
10756       {
10757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10758       };
10759     } catch (...) {
10760       {
10761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10762       };
10763     }
10764   }
10765
10766   jresult = result;
10767   return jresult;
10768 }
10769
10770
10771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10772   void * jresult ;
10773   Dali::Radian arg1 ;
10774   float arg2 ;
10775   Dali::Radian *argp1 ;
10776   Dali::Radian result;
10777
10778   argp1 = (Dali::Radian *)jarg1;
10779   if (!argp1) {
10780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10781     return 0;
10782   }
10783   arg1 = *argp1;
10784   arg2 = (float)jarg2;
10785   {
10786     try {
10787       result = Dali::operator *(arg1,arg2);
10788     } catch (std::out_of_range& e) {
10789       {
10790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10791       };
10792     } catch (std::exception& e) {
10793       {
10794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10795       };
10796     } catch (Dali::DaliException e) {
10797       {
10798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10799       };
10800     } catch (...) {
10801       {
10802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10803       };
10804     }
10805   }
10806
10807   jresult = new Dali::Radian((const Dali::Radian &)result);
10808   return jresult;
10809 }
10810
10811
10812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10813   void * jresult ;
10814   Dali::Radian arg1 ;
10815   Dali::Radian *argp1 ;
10816   Dali::Radian result;
10817
10818   argp1 = (Dali::Radian *)jarg1;
10819   if (!argp1) {
10820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10821     return 0;
10822   }
10823   arg1 = *argp1;
10824   {
10825     try {
10826       result = Dali::operator -(arg1);
10827     } catch (std::out_of_range& e) {
10828       {
10829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10830       };
10831     } catch (std::exception& e) {
10832       {
10833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10834       };
10835     } catch (Dali::DaliException e) {
10836       {
10837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10838       };
10839     } catch (...) {
10840       {
10841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10842       };
10843     }
10844   }
10845
10846   jresult = new Dali::Radian((const Dali::Radian &)result);
10847   return jresult;
10848 }
10849
10850
10851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10852   void * jresult ;
10853   Dali::Radian arg1 ;
10854   float arg2 ;
10855   float arg3 ;
10856   Dali::Radian *argp1 ;
10857   Dali::Radian result;
10858
10859   argp1 = (Dali::Radian *)jarg1;
10860   if (!argp1) {
10861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10862     return 0;
10863   }
10864   arg1 = *argp1;
10865   arg2 = (float)jarg2;
10866   arg3 = (float)jarg3;
10867   {
10868     try {
10869       result = Dali::Clamp(arg1,arg2,arg3);
10870     } catch (std::out_of_range& e) {
10871       {
10872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10873       };
10874     } catch (std::exception& e) {
10875       {
10876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10877       };
10878     } catch (Dali::DaliException e) {
10879       {
10880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10881       };
10882     } catch (...) {
10883       {
10884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10885       };
10886     }
10887   }
10888
10889   jresult = new Dali::Radian((const Dali::Radian &)result);
10890   return jresult;
10891 }
10892
10893
10894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10895   void * jresult ;
10896   Dali::Quaternion *result = 0 ;
10897
10898   {
10899     try {
10900       result = (Dali::Quaternion *)new Dali::Quaternion();
10901     } catch (std::out_of_range& e) {
10902       {
10903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (std::exception& e) {
10906       {
10907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10908       };
10909     } catch (Dali::DaliException e) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10912       };
10913     } catch (...) {
10914       {
10915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10916       };
10917     }
10918   }
10919
10920   jresult = (void *)result;
10921   return jresult;
10922 }
10923
10924
10925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10926   void * jresult ;
10927   Dali::Radian arg1 ;
10928   Dali::Vector3 *arg2 = 0 ;
10929   Dali::Radian *argp1 ;
10930   Dali::Quaternion *result = 0 ;
10931
10932   argp1 = (Dali::Radian *)jarg1;
10933   if (!argp1) {
10934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10935     return 0;
10936   }
10937   arg1 = *argp1;
10938   arg2 = (Dali::Vector3 *)jarg2;
10939   if (!arg2) {
10940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10941     return 0;
10942   }
10943   {
10944     try {
10945       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10946     } catch (std::out_of_range& e) {
10947       {
10948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10949       };
10950     } catch (std::exception& e) {
10951       {
10952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10953       };
10954     } catch (Dali::DaliException e) {
10955       {
10956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10957       };
10958     } catch (...) {
10959       {
10960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10961       };
10962     }
10963   }
10964
10965   jresult = (void *)result;
10966   return jresult;
10967 }
10968
10969
10970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10971   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10972
10973   arg1 = (Dali::Quaternion *)jarg1;
10974   {
10975     try {
10976       delete arg1;
10977     } catch (std::out_of_range& e) {
10978       {
10979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10980       };
10981     } catch (std::exception& e) {
10982       {
10983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10984       };
10985     } catch (Dali::DaliException e) {
10986       {
10987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10988       };
10989     } catch (...) {
10990       {
10991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10992       };
10993     }
10994   }
10995
10996 }
10997
10998
10999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11000   void * jresult ;
11001   Dali::Quaternion *result = 0 ;
11002
11003   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11004   jresult = (void *)result;
11005   return jresult;
11006 }
11007
11008
11009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11010   unsigned int jresult ;
11011   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11012   bool result;
11013
11014   arg1 = (Dali::Quaternion *)jarg1;
11015   {
11016     try {
11017       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11018     } catch (std::out_of_range& e) {
11019       {
11020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (std::exception& e) {
11023       {
11024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11025       };
11026     } catch (Dali::DaliException e) {
11027       {
11028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11029       };
11030     } catch (...) {
11031       {
11032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11033       };
11034     }
11035   }
11036
11037   jresult = result;
11038   return jresult;
11039 }
11040
11041
11042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11043   unsigned int jresult ;
11044   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11045   Dali::Vector3 *arg2 = 0 ;
11046   Dali::Radian *arg3 = 0 ;
11047   bool result;
11048
11049   arg1 = (Dali::Quaternion *)jarg1;
11050   arg2 = (Dali::Vector3 *)jarg2;
11051   if (!arg2) {
11052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11053     return 0;
11054   }
11055   arg3 = (Dali::Radian *)jarg3;
11056   if (!arg3) {
11057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11058     return 0;
11059   }
11060   {
11061     try {
11062       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11063     } catch (std::out_of_range& e) {
11064       {
11065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11066       };
11067     } catch (std::exception& e) {
11068       {
11069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11070       };
11071     } catch (Dali::DaliException e) {
11072       {
11073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11074       };
11075     } catch (...) {
11076       {
11077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11078       };
11079     }
11080   }
11081
11082   jresult = result;
11083   return jresult;
11084 }
11085
11086
11087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11088   void * jresult ;
11089   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11090   Dali::Quaternion *arg2 = 0 ;
11091   Dali::Quaternion result;
11092
11093   arg1 = (Dali::Quaternion *)jarg1;
11094   arg2 = (Dali::Quaternion *)jarg2;
11095   if (!arg2) {
11096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11097     return 0;
11098   }
11099   {
11100     try {
11101       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11102     } catch (std::out_of_range& e) {
11103       {
11104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11105       };
11106     } catch (std::exception& e) {
11107       {
11108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11109       };
11110     } catch (Dali::DaliException e) {
11111       {
11112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11113       };
11114     } catch (...) {
11115       {
11116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11117       };
11118     }
11119   }
11120
11121   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11122   return jresult;
11123 }
11124
11125
11126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11127   void * jresult ;
11128   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11129   Dali::Quaternion *arg2 = 0 ;
11130   Dali::Quaternion result;
11131
11132   arg1 = (Dali::Quaternion *)jarg1;
11133   arg2 = (Dali::Quaternion *)jarg2;
11134   if (!arg2) {
11135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11136     return 0;
11137   }
11138   {
11139     try {
11140       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11141     } catch (std::out_of_range& e) {
11142       {
11143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11144       };
11145     } catch (std::exception& e) {
11146       {
11147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11148       };
11149     } catch (Dali::DaliException e) {
11150       {
11151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11152       };
11153     } catch (...) {
11154       {
11155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11156       };
11157     }
11158   }
11159
11160   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11161   return jresult;
11162 }
11163
11164
11165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11166   void * jresult ;
11167   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11168   Dali::Quaternion *arg2 = 0 ;
11169   Dali::Quaternion result;
11170
11171   arg1 = (Dali::Quaternion *)jarg1;
11172   arg2 = (Dali::Quaternion *)jarg2;
11173   if (!arg2) {
11174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11175     return 0;
11176   }
11177   {
11178     try {
11179       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11180     } catch (std::out_of_range& e) {
11181       {
11182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11183       };
11184     } catch (std::exception& e) {
11185       {
11186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11187       };
11188     } catch (Dali::DaliException e) {
11189       {
11190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11191       };
11192     } catch (...) {
11193       {
11194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11195       };
11196     }
11197   }
11198
11199   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11200   return jresult;
11201 }
11202
11203
11204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11205   void * jresult ;
11206   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11207   Dali::Vector3 *arg2 = 0 ;
11208   Dali::Vector3 result;
11209
11210   arg1 = (Dali::Quaternion *)jarg1;
11211   arg2 = (Dali::Vector3 *)jarg2;
11212   if (!arg2) {
11213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11214     return 0;
11215   }
11216   {
11217     try {
11218       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11219     } catch (std::out_of_range& e) {
11220       {
11221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11222       };
11223     } catch (std::exception& e) {
11224       {
11225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11226       };
11227     } catch (Dali::DaliException e) {
11228       {
11229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11230       };
11231     } catch (...) {
11232       {
11233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11234       };
11235     }
11236   }
11237
11238   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11239   return jresult;
11240 }
11241
11242
11243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11244   void * jresult ;
11245   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11246   Dali::Quaternion *arg2 = 0 ;
11247   Dali::Quaternion result;
11248
11249   arg1 = (Dali::Quaternion *)jarg1;
11250   arg2 = (Dali::Quaternion *)jarg2;
11251   if (!arg2) {
11252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11253     return 0;
11254   }
11255   {
11256     try {
11257       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11258     } catch (std::out_of_range& e) {
11259       {
11260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11261       };
11262     } catch (std::exception& e) {
11263       {
11264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11265       };
11266     } catch (Dali::DaliException e) {
11267       {
11268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11269       };
11270     } catch (...) {
11271       {
11272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11273       };
11274     }
11275   }
11276
11277   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11278   return jresult;
11279 }
11280
11281
11282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11283   void * jresult ;
11284   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11285   float arg2 ;
11286   Dali::Quaternion result;
11287
11288   arg1 = (Dali::Quaternion *)jarg1;
11289   arg2 = (float)jarg2;
11290   {
11291     try {
11292       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11293     } catch (std::out_of_range& e) {
11294       {
11295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11296       };
11297     } catch (std::exception& e) {
11298       {
11299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11300       };
11301     } catch (Dali::DaliException e) {
11302       {
11303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11304       };
11305     } catch (...) {
11306       {
11307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11308       };
11309     }
11310   }
11311
11312   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11313   return jresult;
11314 }
11315
11316
11317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11318   void * jresult ;
11319   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11320   float arg2 ;
11321   Dali::Quaternion result;
11322
11323   arg1 = (Dali::Quaternion *)jarg1;
11324   arg2 = (float)jarg2;
11325   {
11326     try {
11327       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11328     } catch (std::out_of_range& e) {
11329       {
11330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11331       };
11332     } catch (std::exception& e) {
11333       {
11334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11335       };
11336     } catch (Dali::DaliException e) {
11337       {
11338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11339       };
11340     } catch (...) {
11341       {
11342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11343       };
11344     }
11345   }
11346
11347   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11348   return jresult;
11349 }
11350
11351
11352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11353   void * jresult ;
11354   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11355   Dali::Quaternion result;
11356
11357   arg1 = (Dali::Quaternion *)jarg1;
11358   {
11359     try {
11360       result = ((Dali::Quaternion const *)arg1)->operator -();
11361     } catch (std::out_of_range& e) {
11362       {
11363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11364       };
11365     } catch (std::exception& e) {
11366       {
11367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11368       };
11369     } catch (Dali::DaliException e) {
11370       {
11371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11372       };
11373     } catch (...) {
11374       {
11375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11376       };
11377     }
11378   }
11379
11380   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11381   return jresult;
11382 }
11383
11384
11385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11386   void * jresult ;
11387   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11388   Dali::Quaternion *arg2 = 0 ;
11389   Dali::Quaternion *result = 0 ;
11390
11391   arg1 = (Dali::Quaternion *)jarg1;
11392   arg2 = (Dali::Quaternion *)jarg2;
11393   if (!arg2) {
11394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11395     return 0;
11396   }
11397   {
11398     try {
11399       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11400     } catch (std::out_of_range& e) {
11401       {
11402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11403       };
11404     } catch (std::exception& e) {
11405       {
11406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11407       };
11408     } catch (Dali::DaliException e) {
11409       {
11410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11411       };
11412     } catch (...) {
11413       {
11414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11415       };
11416     }
11417   }
11418
11419   jresult = (void *)result;
11420   return jresult;
11421 }
11422
11423
11424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11425   void * jresult ;
11426   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11427   Dali::Quaternion *arg2 = 0 ;
11428   Dali::Quaternion *result = 0 ;
11429
11430   arg1 = (Dali::Quaternion *)jarg1;
11431   arg2 = (Dali::Quaternion *)jarg2;
11432   if (!arg2) {
11433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11434     return 0;
11435   }
11436   {
11437     try {
11438       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11439     } catch (std::out_of_range& e) {
11440       {
11441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11442       };
11443     } catch (std::exception& e) {
11444       {
11445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11446       };
11447     } catch (Dali::DaliException e) {
11448       {
11449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11450       };
11451     } catch (...) {
11452       {
11453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11454       };
11455     }
11456   }
11457
11458   jresult = (void *)result;
11459   return jresult;
11460 }
11461
11462
11463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11464   void * jresult ;
11465   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11466   Dali::Quaternion *arg2 = 0 ;
11467   Dali::Quaternion *result = 0 ;
11468
11469   arg1 = (Dali::Quaternion *)jarg1;
11470   arg2 = (Dali::Quaternion *)jarg2;
11471   if (!arg2) {
11472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11473     return 0;
11474   }
11475   {
11476     try {
11477       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11478     } catch (std::out_of_range& e) {
11479       {
11480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11481       };
11482     } catch (std::exception& e) {
11483       {
11484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11485       };
11486     } catch (Dali::DaliException e) {
11487       {
11488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11489       };
11490     } catch (...) {
11491       {
11492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11493       };
11494     }
11495   }
11496
11497   jresult = (void *)result;
11498   return jresult;
11499 }
11500
11501
11502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11503   void * jresult ;
11504   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11505   float arg2 ;
11506   Dali::Quaternion *result = 0 ;
11507
11508   arg1 = (Dali::Quaternion *)jarg1;
11509   arg2 = (float)jarg2;
11510   {
11511     try {
11512       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11513     } catch (std::out_of_range& e) {
11514       {
11515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11516       };
11517     } catch (std::exception& e) {
11518       {
11519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11520       };
11521     } catch (Dali::DaliException e) {
11522       {
11523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11524       };
11525     } catch (...) {
11526       {
11527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11528       };
11529     }
11530   }
11531
11532   jresult = (void *)result;
11533   return jresult;
11534 }
11535
11536
11537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11538   void * jresult ;
11539   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11540   float arg2 ;
11541   Dali::Quaternion *result = 0 ;
11542
11543   arg1 = (Dali::Quaternion *)jarg1;
11544   arg2 = (float)jarg2;
11545   {
11546     try {
11547       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11548     } catch (std::out_of_range& e) {
11549       {
11550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11551       };
11552     } catch (std::exception& e) {
11553       {
11554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11555       };
11556     } catch (Dali::DaliException e) {
11557       {
11558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11559       };
11560     } catch (...) {
11561       {
11562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11563       };
11564     }
11565   }
11566
11567   jresult = (void *)result;
11568   return jresult;
11569 }
11570
11571
11572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11573   unsigned int jresult ;
11574   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11575   Dali::Quaternion *arg2 = 0 ;
11576   bool result;
11577
11578   arg1 = (Dali::Quaternion *)jarg1;
11579   arg2 = (Dali::Quaternion *)jarg2;
11580   if (!arg2) {
11581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11582     return 0;
11583   }
11584   {
11585     try {
11586       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11587     } catch (std::out_of_range& e) {
11588       {
11589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11590       };
11591     } catch (std::exception& e) {
11592       {
11593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11594       };
11595     } catch (Dali::DaliException e) {
11596       {
11597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11598       };
11599     } catch (...) {
11600       {
11601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11602       };
11603     }
11604   }
11605
11606   jresult = result;
11607   return jresult;
11608 }
11609
11610
11611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11612   unsigned int jresult ;
11613   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11614   Dali::Quaternion *arg2 = 0 ;
11615   bool result;
11616
11617   arg1 = (Dali::Quaternion *)jarg1;
11618   arg2 = (Dali::Quaternion *)jarg2;
11619   if (!arg2) {
11620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11621     return 0;
11622   }
11623   {
11624     try {
11625       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11626     } catch (std::out_of_range& e) {
11627       {
11628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11629       };
11630     } catch (std::exception& e) {
11631       {
11632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11633       };
11634     } catch (Dali::DaliException e) {
11635       {
11636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11637       };
11638     } catch (...) {
11639       {
11640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11641       };
11642     }
11643   }
11644
11645   jresult = result;
11646   return jresult;
11647 }
11648
11649
11650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11651   float jresult ;
11652   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11653   float result;
11654
11655   arg1 = (Dali::Quaternion *)jarg1;
11656   {
11657     try {
11658       result = (float)((Dali::Quaternion const *)arg1)->Length();
11659     } catch (std::out_of_range& e) {
11660       {
11661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11662       };
11663     } catch (std::exception& e) {
11664       {
11665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11666       };
11667     } catch (Dali::DaliException e) {
11668       {
11669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11670       };
11671     } catch (...) {
11672       {
11673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11674       };
11675     }
11676   }
11677
11678   jresult = result;
11679   return jresult;
11680 }
11681
11682
11683 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11684   float jresult ;
11685   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11686   float result;
11687
11688   arg1 = (Dali::Quaternion *)jarg1;
11689   {
11690     try {
11691       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11692     } catch (std::out_of_range& e) {
11693       {
11694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11695       };
11696     } catch (std::exception& e) {
11697       {
11698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11699       };
11700     } catch (Dali::DaliException e) {
11701       {
11702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11703       };
11704     } catch (...) {
11705       {
11706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11707       };
11708     }
11709   }
11710
11711   jresult = result;
11712   return jresult;
11713 }
11714
11715
11716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11717   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11718
11719   arg1 = (Dali::Quaternion *)jarg1;
11720   {
11721     try {
11722       (arg1)->Normalize();
11723     } catch (std::out_of_range& e) {
11724       {
11725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11726       };
11727     } catch (std::exception& e) {
11728       {
11729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11730       };
11731     } catch (Dali::DaliException e) {
11732       {
11733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11734       };
11735     } catch (...) {
11736       {
11737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11738       };
11739     }
11740   }
11741
11742 }
11743
11744
11745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11746   void * jresult ;
11747   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11748   Dali::Quaternion result;
11749
11750   arg1 = (Dali::Quaternion *)jarg1;
11751   {
11752     try {
11753       result = ((Dali::Quaternion const *)arg1)->Normalized();
11754     } catch (std::out_of_range& e) {
11755       {
11756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11757       };
11758     } catch (std::exception& e) {
11759       {
11760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11761       };
11762     } catch (Dali::DaliException e) {
11763       {
11764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11765       };
11766     } catch (...) {
11767       {
11768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11769       };
11770     }
11771   }
11772
11773   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11774   return jresult;
11775 }
11776
11777
11778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11779   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11780
11781   arg1 = (Dali::Quaternion *)jarg1;
11782   {
11783     try {
11784       (arg1)->Conjugate();
11785     } catch (std::out_of_range& e) {
11786       {
11787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11788       };
11789     } catch (std::exception& e) {
11790       {
11791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11792       };
11793     } catch (Dali::DaliException e) {
11794       {
11795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11796       };
11797     } catch (...) {
11798       {
11799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11800       };
11801     }
11802   }
11803
11804 }
11805
11806
11807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11808   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11809
11810   arg1 = (Dali::Quaternion *)jarg1;
11811   {
11812     try {
11813       (arg1)->Invert();
11814     } catch (std::out_of_range& e) {
11815       {
11816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11817       };
11818     } catch (std::exception& e) {
11819       {
11820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11821       };
11822     } catch (Dali::DaliException e) {
11823       {
11824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11825       };
11826     } catch (...) {
11827       {
11828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11829       };
11830     }
11831   }
11832
11833 }
11834
11835
11836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11837   void * jresult ;
11838   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11839   Dali::Quaternion result;
11840
11841   arg1 = (Dali::Quaternion *)jarg1;
11842   {
11843     try {
11844       result = ((Dali::Quaternion const *)arg1)->Log();
11845     } catch (std::out_of_range& e) {
11846       {
11847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11848       };
11849     } catch (std::exception& e) {
11850       {
11851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11852       };
11853     } catch (Dali::DaliException e) {
11854       {
11855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11856       };
11857     } catch (...) {
11858       {
11859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11860       };
11861     }
11862   }
11863
11864   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11865   return jresult;
11866 }
11867
11868
11869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11870   void * jresult ;
11871   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11872   Dali::Quaternion result;
11873
11874   arg1 = (Dali::Quaternion *)jarg1;
11875   {
11876     try {
11877       result = ((Dali::Quaternion const *)arg1)->Exp();
11878     } catch (std::out_of_range& e) {
11879       {
11880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11881       };
11882     } catch (std::exception& e) {
11883       {
11884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11885       };
11886     } catch (Dali::DaliException e) {
11887       {
11888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11889       };
11890     } catch (...) {
11891       {
11892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11893       };
11894     }
11895   }
11896
11897   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11898   return jresult;
11899 }
11900
11901
11902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11903   float jresult ;
11904   Dali::Quaternion *arg1 = 0 ;
11905   Dali::Quaternion *arg2 = 0 ;
11906   float result;
11907
11908   arg1 = (Dali::Quaternion *)jarg1;
11909   if (!arg1) {
11910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11911     return 0;
11912   }
11913   arg2 = (Dali::Quaternion *)jarg2;
11914   if (!arg2) {
11915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11916     return 0;
11917   }
11918   {
11919     try {
11920       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11921     } catch (std::out_of_range& e) {
11922       {
11923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (std::exception& e) {
11926       {
11927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11928       };
11929     } catch (Dali::DaliException e) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11932       };
11933     } catch (...) {
11934       {
11935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11936       };
11937     }
11938   }
11939
11940   jresult = result;
11941   return jresult;
11942 }
11943
11944
11945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11946   void * jresult ;
11947   Dali::Quaternion *arg1 = 0 ;
11948   Dali::Quaternion *arg2 = 0 ;
11949   float arg3 ;
11950   Dali::Quaternion result;
11951
11952   arg1 = (Dali::Quaternion *)jarg1;
11953   if (!arg1) {
11954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11955     return 0;
11956   }
11957   arg2 = (Dali::Quaternion *)jarg2;
11958   if (!arg2) {
11959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11960     return 0;
11961   }
11962   arg3 = (float)jarg3;
11963   {
11964     try {
11965       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11966     } catch (std::out_of_range& e) {
11967       {
11968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (std::exception& e) {
11971       {
11972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11973       };
11974     } catch (Dali::DaliException e) {
11975       {
11976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11977       };
11978     } catch (...) {
11979       {
11980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11981       };
11982     }
11983   }
11984
11985   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11986   return jresult;
11987 }
11988
11989
11990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11991   void * jresult ;
11992   Dali::Quaternion *arg1 = 0 ;
11993   Dali::Quaternion *arg2 = 0 ;
11994   float arg3 ;
11995   Dali::Quaternion result;
11996
11997   arg1 = (Dali::Quaternion *)jarg1;
11998   if (!arg1) {
11999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12000     return 0;
12001   }
12002   arg2 = (Dali::Quaternion *)jarg2;
12003   if (!arg2) {
12004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12005     return 0;
12006   }
12007   arg3 = (float)jarg3;
12008   {
12009     try {
12010       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12011     } catch (std::out_of_range& e) {
12012       {
12013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12014       };
12015     } catch (std::exception& e) {
12016       {
12017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12018       };
12019     } catch (Dali::DaliException e) {
12020       {
12021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12022       };
12023     } catch (...) {
12024       {
12025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12026       };
12027     }
12028   }
12029
12030   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12031   return jresult;
12032 }
12033
12034
12035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12036   void * jresult ;
12037   Dali::Quaternion *arg1 = 0 ;
12038   Dali::Quaternion *arg2 = 0 ;
12039   float arg3 ;
12040   Dali::Quaternion result;
12041
12042   arg1 = (Dali::Quaternion *)jarg1;
12043   if (!arg1) {
12044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12045     return 0;
12046   }
12047   arg2 = (Dali::Quaternion *)jarg2;
12048   if (!arg2) {
12049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12050     return 0;
12051   }
12052   arg3 = (float)jarg3;
12053   {
12054     try {
12055       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12056     } catch (std::out_of_range& e) {
12057       {
12058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12059       };
12060     } catch (std::exception& e) {
12061       {
12062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12063       };
12064     } catch (Dali::DaliException e) {
12065       {
12066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12067       };
12068     } catch (...) {
12069       {
12070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12071       };
12072     }
12073   }
12074
12075   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12076   return jresult;
12077 }
12078
12079
12080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12081   void * jresult ;
12082   Dali::Quaternion *arg1 = 0 ;
12083   Dali::Quaternion *arg2 = 0 ;
12084   Dali::Quaternion *arg3 = 0 ;
12085   Dali::Quaternion *arg4 = 0 ;
12086   float arg5 ;
12087   Dali::Quaternion result;
12088
12089   arg1 = (Dali::Quaternion *)jarg1;
12090   if (!arg1) {
12091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12092     return 0;
12093   }
12094   arg2 = (Dali::Quaternion *)jarg2;
12095   if (!arg2) {
12096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12097     return 0;
12098   }
12099   arg3 = (Dali::Quaternion *)jarg3;
12100   if (!arg3) {
12101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12102     return 0;
12103   }
12104   arg4 = (Dali::Quaternion *)jarg4;
12105   if (!arg4) {
12106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12107     return 0;
12108   }
12109   arg5 = (float)jarg5;
12110   {
12111     try {
12112       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12113     } catch (std::out_of_range& e) {
12114       {
12115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12116       };
12117     } catch (std::exception& e) {
12118       {
12119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12120       };
12121     } catch (Dali::DaliException e) {
12122       {
12123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12124       };
12125     } catch (...) {
12126       {
12127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12128       };
12129     }
12130   }
12131
12132   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12133   return jresult;
12134 }
12135
12136
12137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12138   float jresult ;
12139   Dali::Quaternion *arg1 = 0 ;
12140   Dali::Quaternion *arg2 = 0 ;
12141   float result;
12142
12143   arg1 = (Dali::Quaternion *)jarg1;
12144   if (!arg1) {
12145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12146     return 0;
12147   }
12148   arg2 = (Dali::Quaternion *)jarg2;
12149   if (!arg2) {
12150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12151     return 0;
12152   }
12153   {
12154     try {
12155       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12156     } catch (std::out_of_range& e) {
12157       {
12158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12159       };
12160     } catch (std::exception& e) {
12161       {
12162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12163       };
12164     } catch (Dali::DaliException e) {
12165       {
12166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12167       };
12168     } catch (...) {
12169       {
12170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12171       };
12172     }
12173   }
12174
12175   jresult = result;
12176   return jresult;
12177 }
12178
12179
12180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12181   void * jresult ;
12182   Dali::Matrix *result = 0 ;
12183
12184   {
12185     try {
12186       result = (Dali::Matrix *)new Dali::Matrix();
12187     } catch (std::out_of_range& e) {
12188       {
12189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12190       };
12191     } catch (std::exception& e) {
12192       {
12193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12194       };
12195     } catch (Dali::DaliException e) {
12196       {
12197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12198       };
12199     } catch (...) {
12200       {
12201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12202       };
12203     }
12204   }
12205
12206   jresult = (void *)result;
12207   return jresult;
12208 }
12209
12210
12211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12212   void * jresult ;
12213   bool arg1 ;
12214   Dali::Matrix *result = 0 ;
12215
12216   arg1 = jarg1 ? true : false;
12217   {
12218     try {
12219       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12220     } catch (std::out_of_range& e) {
12221       {
12222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12223       };
12224     } catch (std::exception& e) {
12225       {
12226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12227       };
12228     } catch (Dali::DaliException e) {
12229       {
12230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12231       };
12232     } catch (...) {
12233       {
12234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12235       };
12236     }
12237   }
12238
12239   jresult = (void *)result;
12240   return jresult;
12241 }
12242
12243
12244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12245   void * jresult ;
12246   float *arg1 = (float *) 0 ;
12247   Dali::Matrix *result = 0 ;
12248
12249   arg1 = jarg1;
12250   {
12251     try {
12252       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12253     } catch (std::out_of_range& e) {
12254       {
12255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12256       };
12257     } catch (std::exception& e) {
12258       {
12259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12260       };
12261     } catch (Dali::DaliException e) {
12262       {
12263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12264       };
12265     } catch (...) {
12266       {
12267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12268       };
12269     }
12270   }
12271
12272   jresult = (void *)result;
12273
12274
12275   return jresult;
12276 }
12277
12278
12279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12280   void * jresult ;
12281   Dali::Quaternion *arg1 = 0 ;
12282   Dali::Matrix *result = 0 ;
12283
12284   arg1 = (Dali::Quaternion *)jarg1;
12285   if (!arg1) {
12286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12287     return 0;
12288   }
12289   {
12290     try {
12291       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12292     } catch (std::out_of_range& e) {
12293       {
12294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12295       };
12296     } catch (std::exception& e) {
12297       {
12298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12299       };
12300     } catch (Dali::DaliException e) {
12301       {
12302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12303       };
12304     } catch (...) {
12305       {
12306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12307       };
12308     }
12309   }
12310
12311   jresult = (void *)result;
12312   return jresult;
12313 }
12314
12315
12316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12317   void * jresult ;
12318   Dali::Matrix *arg1 = 0 ;
12319   Dali::Matrix *result = 0 ;
12320
12321   arg1 = (Dali::Matrix *)jarg1;
12322   if (!arg1) {
12323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12324     return 0;
12325   }
12326   {
12327     try {
12328       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12329     } catch (std::out_of_range& e) {
12330       {
12331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12332       };
12333     } catch (std::exception& e) {
12334       {
12335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12336       };
12337     } catch (Dali::DaliException e) {
12338       {
12339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12340       };
12341     } catch (...) {
12342       {
12343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12344       };
12345     }
12346   }
12347
12348   jresult = (void *)result;
12349   return jresult;
12350 }
12351
12352
12353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12354   void * jresult ;
12355   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12356   Dali::Matrix *arg2 = 0 ;
12357   Dali::Matrix *result = 0 ;
12358
12359   arg1 = (Dali::Matrix *)jarg1;
12360   arg2 = (Dali::Matrix *)jarg2;
12361   if (!arg2) {
12362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12363     return 0;
12364   }
12365   {
12366     try {
12367       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12368     } catch (std::out_of_range& e) {
12369       {
12370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12371       };
12372     } catch (std::exception& e) {
12373       {
12374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12375       };
12376     } catch (Dali::DaliException e) {
12377       {
12378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12379       };
12380     } catch (...) {
12381       {
12382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12383       };
12384     }
12385   }
12386
12387   jresult = (void *)result;
12388   return jresult;
12389 }
12390
12391
12392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12393   void * jresult ;
12394   Dali::Matrix *result = 0 ;
12395
12396   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12397   jresult = (void *)result;
12398   return jresult;
12399 }
12400
12401
12402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12403   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12404
12405   arg1 = (Dali::Matrix *)jarg1;
12406   {
12407     try {
12408       (arg1)->SetIdentity();
12409     } catch (std::out_of_range& e) {
12410       {
12411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12412       };
12413     } catch (std::exception& e) {
12414       {
12415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12416       };
12417     } catch (Dali::DaliException e) {
12418       {
12419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12420       };
12421     } catch (...) {
12422       {
12423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12424       };
12425     }
12426   }
12427
12428 }
12429
12430
12431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12432   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12433   Dali::Vector3 *arg2 = 0 ;
12434
12435   arg1 = (Dali::Matrix *)jarg1;
12436   arg2 = (Dali::Vector3 *)jarg2;
12437   if (!arg2) {
12438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12439     return ;
12440   }
12441   {
12442     try {
12443       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12444     } catch (std::out_of_range& e) {
12445       {
12446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12447       };
12448     } catch (std::exception& e) {
12449       {
12450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12451       };
12452     } catch (Dali::DaliException e) {
12453       {
12454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12455       };
12456     } catch (...) {
12457       {
12458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12459       };
12460     }
12461   }
12462
12463 }
12464
12465
12466 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12467   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12468   Dali::Matrix *arg2 = 0 ;
12469
12470   arg1 = (Dali::Matrix *)jarg1;
12471   arg2 = (Dali::Matrix *)jarg2;
12472   if (!arg2) {
12473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12474     return ;
12475   }
12476   {
12477     try {
12478       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12479     } catch (std::out_of_range& e) {
12480       {
12481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12482       };
12483     } catch (std::exception& e) {
12484       {
12485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12486       };
12487     } catch (Dali::DaliException e) {
12488       {
12489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12490       };
12491     } catch (...) {
12492       {
12493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12494       };
12495     }
12496   }
12497
12498 }
12499
12500
12501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12502   unsigned int jresult ;
12503   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12504   bool result;
12505
12506   arg1 = (Dali::Matrix *)jarg1;
12507   {
12508     try {
12509       result = (bool)(arg1)->Invert();
12510     } catch (std::out_of_range& e) {
12511       {
12512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12513       };
12514     } catch (std::exception& e) {
12515       {
12516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12517       };
12518     } catch (Dali::DaliException e) {
12519       {
12520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12521       };
12522     } catch (...) {
12523       {
12524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12525       };
12526     }
12527   }
12528
12529   jresult = result;
12530   return jresult;
12531 }
12532
12533
12534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12535   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12536
12537   arg1 = (Dali::Matrix *)jarg1;
12538   {
12539     try {
12540       (arg1)->Transpose();
12541     } catch (std::out_of_range& e) {
12542       {
12543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12544       };
12545     } catch (std::exception& e) {
12546       {
12547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12548       };
12549     } catch (Dali::DaliException e) {
12550       {
12551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12552       };
12553     } catch (...) {
12554       {
12555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12556       };
12557     }
12558   }
12559
12560 }
12561
12562
12563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12564   void * jresult ;
12565   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12566   Dali::Vector3 result;
12567
12568   arg1 = (Dali::Matrix *)jarg1;
12569   {
12570     try {
12571       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12572     } catch (std::out_of_range& e) {
12573       {
12574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12575       };
12576     } catch (std::exception& e) {
12577       {
12578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12579       };
12580     } catch (Dali::DaliException e) {
12581       {
12582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12583       };
12584     } catch (...) {
12585       {
12586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12587       };
12588     }
12589   }
12590
12591   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12592   return jresult;
12593 }
12594
12595
12596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12597   void * jresult ;
12598   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12599   Dali::Vector3 result;
12600
12601   arg1 = (Dali::Matrix *)jarg1;
12602   {
12603     try {
12604       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12605     } catch (std::out_of_range& e) {
12606       {
12607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12608       };
12609     } catch (std::exception& e) {
12610       {
12611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12612       };
12613     } catch (Dali::DaliException e) {
12614       {
12615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12616       };
12617     } catch (...) {
12618       {
12619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12620       };
12621     }
12622   }
12623
12624   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12625   return jresult;
12626 }
12627
12628
12629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12630   void * jresult ;
12631   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12632   Dali::Vector3 result;
12633
12634   arg1 = (Dali::Matrix *)jarg1;
12635   {
12636     try {
12637       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12638     } catch (std::out_of_range& e) {
12639       {
12640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12641       };
12642     } catch (std::exception& e) {
12643       {
12644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12645       };
12646     } catch (Dali::DaliException e) {
12647       {
12648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12649       };
12650     } catch (...) {
12651       {
12652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12653       };
12654     }
12655   }
12656
12657   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12658   return jresult;
12659 }
12660
12661
12662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12663   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12664   Dali::Vector3 *arg2 = 0 ;
12665
12666   arg1 = (Dali::Matrix *)jarg1;
12667   arg2 = (Dali::Vector3 *)jarg2;
12668   if (!arg2) {
12669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12670     return ;
12671   }
12672   {
12673     try {
12674       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12675     } catch (std::out_of_range& e) {
12676       {
12677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12678       };
12679     } catch (std::exception& e) {
12680       {
12681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12682       };
12683     } catch (Dali::DaliException e) {
12684       {
12685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12686       };
12687     } catch (...) {
12688       {
12689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12690       };
12691     }
12692   }
12693
12694 }
12695
12696
12697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12698   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12699   Dali::Vector3 *arg2 = 0 ;
12700
12701   arg1 = (Dali::Matrix *)jarg1;
12702   arg2 = (Dali::Vector3 *)jarg2;
12703   if (!arg2) {
12704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12705     return ;
12706   }
12707   {
12708     try {
12709       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12710     } catch (std::out_of_range& e) {
12711       {
12712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12713       };
12714     } catch (std::exception& e) {
12715       {
12716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12717       };
12718     } catch (Dali::DaliException e) {
12719       {
12720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12721       };
12722     } catch (...) {
12723       {
12724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12725       };
12726     }
12727   }
12728
12729 }
12730
12731
12732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12733   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12734   Dali::Vector3 *arg2 = 0 ;
12735
12736   arg1 = (Dali::Matrix *)jarg1;
12737   arg2 = (Dali::Vector3 *)jarg2;
12738   if (!arg2) {
12739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12740     return ;
12741   }
12742   {
12743     try {
12744       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12745     } catch (std::out_of_range& e) {
12746       {
12747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12748       };
12749     } catch (std::exception& e) {
12750       {
12751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12752       };
12753     } catch (Dali::DaliException e) {
12754       {
12755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12756       };
12757     } catch (...) {
12758       {
12759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12760       };
12761     }
12762   }
12763
12764 }
12765
12766
12767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12768   void * jresult ;
12769   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12770   Dali::Vector4 *result = 0 ;
12771
12772   arg1 = (Dali::Matrix *)jarg1;
12773   {
12774     try {
12775       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12776     } catch (std::out_of_range& e) {
12777       {
12778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12779       };
12780     } catch (std::exception& e) {
12781       {
12782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12783       };
12784     } catch (Dali::DaliException e) {
12785       {
12786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12787       };
12788     } catch (...) {
12789       {
12790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12791       };
12792     }
12793   }
12794
12795   jresult = (void *)result;
12796   return jresult;
12797 }
12798
12799
12800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12801   void * jresult ;
12802   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12803   Dali::Vector3 *result = 0 ;
12804
12805   arg1 = (Dali::Matrix *)jarg1;
12806   {
12807     try {
12808       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12809     } catch (std::out_of_range& e) {
12810       {
12811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12812       };
12813     } catch (std::exception& e) {
12814       {
12815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12816       };
12817     } catch (Dali::DaliException e) {
12818       {
12819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12820       };
12821     } catch (...) {
12822       {
12823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12824       };
12825     }
12826   }
12827
12828   jresult = (void *)result;
12829   return jresult;
12830 }
12831
12832
12833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12834   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12835   Dali::Vector4 *arg2 = 0 ;
12836
12837   arg1 = (Dali::Matrix *)jarg1;
12838   arg2 = (Dali::Vector4 *)jarg2;
12839   if (!arg2) {
12840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12841     return ;
12842   }
12843   {
12844     try {
12845       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12846     } catch (std::out_of_range& e) {
12847       {
12848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12849       };
12850     } catch (std::exception& e) {
12851       {
12852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12853       };
12854     } catch (Dali::DaliException e) {
12855       {
12856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12857       };
12858     } catch (...) {
12859       {
12860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12861       };
12862     }
12863   }
12864
12865 }
12866
12867
12868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12869   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12870   Dali::Vector3 *arg2 = 0 ;
12871
12872   arg1 = (Dali::Matrix *)jarg1;
12873   arg2 = (Dali::Vector3 *)jarg2;
12874   if (!arg2) {
12875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12876     return ;
12877   }
12878   {
12879     try {
12880       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12881     } catch (std::out_of_range& e) {
12882       {
12883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12884       };
12885     } catch (std::exception& e) {
12886       {
12887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12888       };
12889     } catch (Dali::DaliException e) {
12890       {
12891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12892       };
12893     } catch (...) {
12894       {
12895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12896       };
12897     }
12898   }
12899
12900 }
12901
12902
12903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12904   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12905
12906   arg1 = (Dali::Matrix *)jarg1;
12907   {
12908     try {
12909       (arg1)->OrthoNormalize();
12910     } catch (std::out_of_range& e) {
12911       {
12912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12913       };
12914     } catch (std::exception& e) {
12915       {
12916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12917       };
12918     } catch (Dali::DaliException e) {
12919       {
12920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12921       };
12922     } catch (...) {
12923       {
12924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12925       };
12926     }
12927   }
12928
12929 }
12930
12931
12932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12933   void * jresult ;
12934   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12935   float *result = 0 ;
12936
12937   arg1 = (Dali::Matrix *)jarg1;
12938   {
12939     try {
12940       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12941     } catch (std::out_of_range& e) {
12942       {
12943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12944       };
12945     } catch (std::exception& e) {
12946       {
12947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12948       };
12949     } catch (Dali::DaliException e) {
12950       {
12951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12952       };
12953     } catch (...) {
12954       {
12955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12956       };
12957     }
12958   }
12959
12960   jresult = (void *)result;
12961   return jresult;
12962 }
12963
12964
12965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12966   Dali::Matrix *arg1 = 0 ;
12967   Dali::Matrix *arg2 = 0 ;
12968   Dali::Matrix *arg3 = 0 ;
12969
12970   arg1 = (Dali::Matrix *)jarg1;
12971   if (!arg1) {
12972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12973     return ;
12974   }
12975   arg2 = (Dali::Matrix *)jarg2;
12976   if (!arg2) {
12977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12978     return ;
12979   }
12980   arg3 = (Dali::Matrix *)jarg3;
12981   if (!arg3) {
12982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12983     return ;
12984   }
12985   {
12986     try {
12987       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12988     } catch (std::out_of_range& e) {
12989       {
12990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12991       };
12992     } catch (std::exception& e) {
12993       {
12994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12995       };
12996     } catch (Dali::DaliException e) {
12997       {
12998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12999       };
13000     } catch (...) {
13001       {
13002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13003       };
13004     }
13005   }
13006
13007 }
13008
13009
13010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13011   Dali::Matrix *arg1 = 0 ;
13012   Dali::Matrix *arg2 = 0 ;
13013   Dali::Quaternion *arg3 = 0 ;
13014
13015   arg1 = (Dali::Matrix *)jarg1;
13016   if (!arg1) {
13017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13018     return ;
13019   }
13020   arg2 = (Dali::Matrix *)jarg2;
13021   if (!arg2) {
13022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13023     return ;
13024   }
13025   arg3 = (Dali::Quaternion *)jarg3;
13026   if (!arg3) {
13027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13028     return ;
13029   }
13030   {
13031     try {
13032       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13033     } catch (std::out_of_range& e) {
13034       {
13035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13036       };
13037     } catch (std::exception& e) {
13038       {
13039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13040       };
13041     } catch (Dali::DaliException e) {
13042       {
13043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13044       };
13045     } catch (...) {
13046       {
13047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13048       };
13049     }
13050   }
13051
13052 }
13053
13054
13055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13056   void * jresult ;
13057   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13058   Dali::Vector4 *arg2 = 0 ;
13059   Dali::Vector4 result;
13060
13061   arg1 = (Dali::Matrix *)jarg1;
13062   arg2 = (Dali::Vector4 *)jarg2;
13063   if (!arg2) {
13064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13065     return 0;
13066   }
13067   {
13068     try {
13069       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13070     } catch (std::out_of_range& e) {
13071       {
13072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13073       };
13074     } catch (std::exception& e) {
13075       {
13076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13077       };
13078     } catch (Dali::DaliException e) {
13079       {
13080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13081       };
13082     } catch (...) {
13083       {
13084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13085       };
13086     }
13087   }
13088
13089   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13090   return jresult;
13091 }
13092
13093
13094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13095   unsigned int jresult ;
13096   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13097   Dali::Matrix *arg2 = 0 ;
13098   bool result;
13099
13100   arg1 = (Dali::Matrix *)jarg1;
13101   arg2 = (Dali::Matrix *)jarg2;
13102   if (!arg2) {
13103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13104     return 0;
13105   }
13106   {
13107     try {
13108       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13109     } catch (std::out_of_range& e) {
13110       {
13111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13112       };
13113     } catch (std::exception& e) {
13114       {
13115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13116       };
13117     } catch (Dali::DaliException e) {
13118       {
13119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13120       };
13121     } catch (...) {
13122       {
13123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13124       };
13125     }
13126   }
13127
13128   jresult = result;
13129   return jresult;
13130 }
13131
13132
13133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13134   unsigned int jresult ;
13135   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13136   Dali::Matrix *arg2 = 0 ;
13137   bool result;
13138
13139   arg1 = (Dali::Matrix *)jarg1;
13140   arg2 = (Dali::Matrix *)jarg2;
13141   if (!arg2) {
13142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13143     return 0;
13144   }
13145   {
13146     try {
13147       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13148     } catch (std::out_of_range& e) {
13149       {
13150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13151       };
13152     } catch (std::exception& e) {
13153       {
13154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13155       };
13156     } catch (Dali::DaliException e) {
13157       {
13158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13159       };
13160     } catch (...) {
13161       {
13162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13163       };
13164     }
13165   }
13166
13167   jresult = result;
13168   return jresult;
13169 }
13170
13171
13172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13173   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13174   Dali::Vector3 *arg2 = 0 ;
13175   Dali::Quaternion *arg3 = 0 ;
13176   Dali::Vector3 *arg4 = 0 ;
13177
13178   arg1 = (Dali::Matrix *)jarg1;
13179   arg2 = (Dali::Vector3 *)jarg2;
13180   if (!arg2) {
13181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13182     return ;
13183   }
13184   arg3 = (Dali::Quaternion *)jarg3;
13185   if (!arg3) {
13186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13187     return ;
13188   }
13189   arg4 = (Dali::Vector3 *)jarg4;
13190   if (!arg4) {
13191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13192     return ;
13193   }
13194   {
13195     try {
13196       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13197     } catch (std::out_of_range& e) {
13198       {
13199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13200       };
13201     } catch (std::exception& e) {
13202       {
13203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13204       };
13205     } catch (Dali::DaliException e) {
13206       {
13207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13208       };
13209     } catch (...) {
13210       {
13211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13212       };
13213     }
13214   }
13215
13216 }
13217
13218
13219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13220   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13221   Dali::Vector3 *arg2 = 0 ;
13222   Dali::Quaternion *arg3 = 0 ;
13223   Dali::Vector3 *arg4 = 0 ;
13224
13225   arg1 = (Dali::Matrix *)jarg1;
13226   arg2 = (Dali::Vector3 *)jarg2;
13227   if (!arg2) {
13228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13229     return ;
13230   }
13231   arg3 = (Dali::Quaternion *)jarg3;
13232   if (!arg3) {
13233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13234     return ;
13235   }
13236   arg4 = (Dali::Vector3 *)jarg4;
13237   if (!arg4) {
13238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13239     return ;
13240   }
13241   {
13242     try {
13243       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13244     } catch (std::out_of_range& e) {
13245       {
13246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13247       };
13248     } catch (std::exception& e) {
13249       {
13250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13251       };
13252     } catch (Dali::DaliException e) {
13253       {
13254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13255       };
13256     } catch (...) {
13257       {
13258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13259       };
13260     }
13261   }
13262
13263 }
13264
13265
13266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13267   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13268   Dali::Vector3 *arg2 = 0 ;
13269   Dali::Vector3 *arg3 = 0 ;
13270   Dali::Vector3 *arg4 = 0 ;
13271   Dali::Vector3 *arg5 = 0 ;
13272
13273   arg1 = (Dali::Matrix *)jarg1;
13274   arg2 = (Dali::Vector3 *)jarg2;
13275   if (!arg2) {
13276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13277     return ;
13278   }
13279   arg3 = (Dali::Vector3 *)jarg3;
13280   if (!arg3) {
13281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13282     return ;
13283   }
13284   arg4 = (Dali::Vector3 *)jarg4;
13285   if (!arg4) {
13286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13287     return ;
13288   }
13289   arg5 = (Dali::Vector3 *)jarg5;
13290   if (!arg5) {
13291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13292     return ;
13293   }
13294   {
13295     try {
13296       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13297     } catch (std::out_of_range& e) {
13298       {
13299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13300       };
13301     } catch (std::exception& e) {
13302       {
13303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13304       };
13305     } catch (Dali::DaliException e) {
13306       {
13307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13308       };
13309     } catch (...) {
13310       {
13311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13312       };
13313     }
13314   }
13315
13316 }
13317
13318
13319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13320   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13321   Dali::Vector3 *arg2 = 0 ;
13322   Dali::Quaternion *arg3 = 0 ;
13323   Dali::Vector3 *arg4 = 0 ;
13324
13325   arg1 = (Dali::Matrix *)jarg1;
13326   arg2 = (Dali::Vector3 *)jarg2;
13327   if (!arg2) {
13328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13329     return ;
13330   }
13331   arg3 = (Dali::Quaternion *)jarg3;
13332   if (!arg3) {
13333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13334     return ;
13335   }
13336   arg4 = (Dali::Vector3 *)jarg4;
13337   if (!arg4) {
13338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13339     return ;
13340   }
13341   {
13342     try {
13343       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13344     } catch (std::out_of_range& e) {
13345       {
13346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13347       };
13348     } catch (std::exception& e) {
13349       {
13350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13351       };
13352     } catch (Dali::DaliException e) {
13353       {
13354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13355       };
13356     } catch (...) {
13357       {
13358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13359       };
13360     }
13361   }
13362
13363 }
13364
13365
13366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13367   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13368
13369   arg1 = (Dali::Matrix *)jarg1;
13370   {
13371     try {
13372       delete arg1;
13373     } catch (std::out_of_range& e) {
13374       {
13375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13376       };
13377     } catch (std::exception& e) {
13378       {
13379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13380       };
13381     } catch (Dali::DaliException e) {
13382       {
13383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13384       };
13385     } catch (...) {
13386       {
13387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13388       };
13389     }
13390   }
13391
13392 }
13393
13394
13395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13396   void * jresult ;
13397   Dali::Matrix3 *result = 0 ;
13398
13399   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13400   jresult = (void *)result;
13401   return jresult;
13402 }
13403
13404
13405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13406   void * jresult ;
13407   Dali::Matrix3 *result = 0 ;
13408
13409   {
13410     try {
13411       result = (Dali::Matrix3 *)new Dali::Matrix3();
13412     } catch (std::out_of_range& e) {
13413       {
13414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13415       };
13416     } catch (std::exception& e) {
13417       {
13418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13419       };
13420     } catch (Dali::DaliException e) {
13421       {
13422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13423       };
13424     } catch (...) {
13425       {
13426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13427       };
13428     }
13429   }
13430
13431   jresult = (void *)result;
13432   return jresult;
13433 }
13434
13435
13436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13437   void * jresult ;
13438   Dali::Matrix3 *arg1 = 0 ;
13439   Dali::Matrix3 *result = 0 ;
13440
13441   arg1 = (Dali::Matrix3 *)jarg1;
13442   if (!arg1) {
13443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13444     return 0;
13445   }
13446   {
13447     try {
13448       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13449     } catch (std::out_of_range& e) {
13450       {
13451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13452       };
13453     } catch (std::exception& e) {
13454       {
13455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13456       };
13457     } catch (Dali::DaliException e) {
13458       {
13459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13460       };
13461     } catch (...) {
13462       {
13463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13464       };
13465     }
13466   }
13467
13468   jresult = (void *)result;
13469   return jresult;
13470 }
13471
13472
13473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13474   void * jresult ;
13475   Dali::Matrix *arg1 = 0 ;
13476   Dali::Matrix3 *result = 0 ;
13477
13478   arg1 = (Dali::Matrix *)jarg1;
13479   if (!arg1) {
13480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13481     return 0;
13482   }
13483   {
13484     try {
13485       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13486     } catch (std::out_of_range& e) {
13487       {
13488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13489       };
13490     } catch (std::exception& e) {
13491       {
13492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13493       };
13494     } catch (Dali::DaliException e) {
13495       {
13496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13497       };
13498     } catch (...) {
13499       {
13500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13501       };
13502     }
13503   }
13504
13505   jresult = (void *)result;
13506   return jresult;
13507 }
13508
13509
13510 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) {
13511   void * jresult ;
13512   float arg1 ;
13513   float arg2 ;
13514   float arg3 ;
13515   float arg4 ;
13516   float arg5 ;
13517   float arg6 ;
13518   float arg7 ;
13519   float arg8 ;
13520   float arg9 ;
13521   Dali::Matrix3 *result = 0 ;
13522
13523   arg1 = (float)jarg1;
13524   arg2 = (float)jarg2;
13525   arg3 = (float)jarg3;
13526   arg4 = (float)jarg4;
13527   arg5 = (float)jarg5;
13528   arg6 = (float)jarg6;
13529   arg7 = (float)jarg7;
13530   arg8 = (float)jarg8;
13531   arg9 = (float)jarg9;
13532   {
13533     try {
13534       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13535     } catch (std::out_of_range& e) {
13536       {
13537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13538       };
13539     } catch (std::exception& e) {
13540       {
13541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13542       };
13543     } catch (Dali::DaliException e) {
13544       {
13545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13546       };
13547     } catch (...) {
13548       {
13549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13550       };
13551     }
13552   }
13553
13554   jresult = (void *)result;
13555   return jresult;
13556 }
13557
13558
13559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13560   void * jresult ;
13561   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13562   Dali::Matrix3 *arg2 = 0 ;
13563   Dali::Matrix3 *result = 0 ;
13564
13565   arg1 = (Dali::Matrix3 *)jarg1;
13566   arg2 = (Dali::Matrix3 *)jarg2;
13567   if (!arg2) {
13568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13569     return 0;
13570   }
13571   {
13572     try {
13573       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13574     } catch (std::out_of_range& e) {
13575       {
13576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13577       };
13578     } catch (std::exception& e) {
13579       {
13580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13581       };
13582     } catch (Dali::DaliException e) {
13583       {
13584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13585       };
13586     } catch (...) {
13587       {
13588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13589       };
13590     }
13591   }
13592
13593   jresult = (void *)result;
13594   return jresult;
13595 }
13596
13597
13598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13599   void * jresult ;
13600   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13601   Dali::Matrix *arg2 = 0 ;
13602   Dali::Matrix3 *result = 0 ;
13603
13604   arg1 = (Dali::Matrix3 *)jarg1;
13605   arg2 = (Dali::Matrix *)jarg2;
13606   if (!arg2) {
13607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13608     return 0;
13609   }
13610   {
13611     try {
13612       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13613     } catch (std::out_of_range& e) {
13614       {
13615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13616       };
13617     } catch (std::exception& e) {
13618       {
13619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13620       };
13621     } catch (Dali::DaliException e) {
13622       {
13623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13624       };
13625     } catch (...) {
13626       {
13627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13628       };
13629     }
13630   }
13631
13632   jresult = (void *)result;
13633   return jresult;
13634 }
13635
13636
13637 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13638   unsigned int jresult ;
13639   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13640   Dali::Matrix3 *arg2 = 0 ;
13641   bool result;
13642
13643   arg1 = (Dali::Matrix3 *)jarg1;
13644   arg2 = (Dali::Matrix3 *)jarg2;
13645   if (!arg2) {
13646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13647     return 0;
13648   }
13649   {
13650     try {
13651       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13652     } catch (std::out_of_range& e) {
13653       {
13654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13655       };
13656     } catch (std::exception& e) {
13657       {
13658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13659       };
13660     } catch (Dali::DaliException e) {
13661       {
13662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13663       };
13664     } catch (...) {
13665       {
13666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13667       };
13668     }
13669   }
13670
13671   jresult = result;
13672   return jresult;
13673 }
13674
13675
13676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13677   unsigned int jresult ;
13678   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13679   Dali::Matrix3 *arg2 = 0 ;
13680   bool result;
13681
13682   arg1 = (Dali::Matrix3 *)jarg1;
13683   arg2 = (Dali::Matrix3 *)jarg2;
13684   if (!arg2) {
13685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13686     return 0;
13687   }
13688   {
13689     try {
13690       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13691     } catch (std::out_of_range& e) {
13692       {
13693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13694       };
13695     } catch (std::exception& e) {
13696       {
13697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13698       };
13699     } catch (Dali::DaliException e) {
13700       {
13701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13702       };
13703     } catch (...) {
13704       {
13705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13706       };
13707     }
13708   }
13709
13710   jresult = result;
13711   return jresult;
13712 }
13713
13714
13715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13716   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13717
13718   arg1 = (Dali::Matrix3 *)jarg1;
13719   {
13720     try {
13721       delete arg1;
13722     } catch (std::out_of_range& e) {
13723       {
13724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13725       };
13726     } catch (std::exception& e) {
13727       {
13728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13729       };
13730     } catch (Dali::DaliException e) {
13731       {
13732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13733       };
13734     } catch (...) {
13735       {
13736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13737       };
13738     }
13739   }
13740
13741 }
13742
13743
13744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13745   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13746
13747   arg1 = (Dali::Matrix3 *)jarg1;
13748   {
13749     try {
13750       (arg1)->SetIdentity();
13751     } catch (std::out_of_range& e) {
13752       {
13753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13754       };
13755     } catch (std::exception& e) {
13756       {
13757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13758       };
13759     } catch (Dali::DaliException e) {
13760       {
13761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13762       };
13763     } catch (...) {
13764       {
13765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13766       };
13767     }
13768   }
13769
13770 }
13771
13772
13773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13774   void * jresult ;
13775   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13776   float *result = 0 ;
13777
13778   arg1 = (Dali::Matrix3 *)jarg1;
13779   {
13780     try {
13781       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13782     } catch (std::out_of_range& e) {
13783       {
13784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13785       };
13786     } catch (std::exception& e) {
13787       {
13788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13789       };
13790     } catch (Dali::DaliException e) {
13791       {
13792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13793       };
13794     } catch (...) {
13795       {
13796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13797       };
13798     }
13799   }
13800
13801   jresult = (void *)result;
13802   return jresult;
13803 }
13804
13805
13806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13807   unsigned int jresult ;
13808   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13809   bool result;
13810
13811   arg1 = (Dali::Matrix3 *)jarg1;
13812   {
13813     try {
13814       result = (bool)(arg1)->Invert();
13815     } catch (std::out_of_range& e) {
13816       {
13817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13818       };
13819     } catch (std::exception& e) {
13820       {
13821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13822       };
13823     } catch (Dali::DaliException e) {
13824       {
13825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13826       };
13827     } catch (...) {
13828       {
13829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13830       };
13831     }
13832   }
13833
13834   jresult = result;
13835   return jresult;
13836 }
13837
13838
13839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13840   unsigned int jresult ;
13841   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13842   bool result;
13843
13844   arg1 = (Dali::Matrix3 *)jarg1;
13845   {
13846     try {
13847       result = (bool)(arg1)->Transpose();
13848     } catch (std::out_of_range& e) {
13849       {
13850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13851       };
13852     } catch (std::exception& e) {
13853       {
13854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13855       };
13856     } catch (Dali::DaliException e) {
13857       {
13858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13859       };
13860     } catch (...) {
13861       {
13862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13863       };
13864     }
13865   }
13866
13867   jresult = result;
13868   return jresult;
13869 }
13870
13871
13872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13873   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13874   float arg2 ;
13875
13876   arg1 = (Dali::Matrix3 *)jarg1;
13877   arg2 = (float)jarg2;
13878   {
13879     try {
13880       (arg1)->Scale(arg2);
13881     } catch (std::out_of_range& e) {
13882       {
13883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13884       };
13885     } catch (std::exception& e) {
13886       {
13887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13888       };
13889     } catch (Dali::DaliException e) {
13890       {
13891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13892       };
13893     } catch (...) {
13894       {
13895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13896       };
13897     }
13898   }
13899
13900 }
13901
13902
13903 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13904   float jresult ;
13905   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13906   float result;
13907
13908   arg1 = (Dali::Matrix3 *)jarg1;
13909   {
13910     try {
13911       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13912     } catch (std::out_of_range& e) {
13913       {
13914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13915       };
13916     } catch (std::exception& e) {
13917       {
13918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13919       };
13920     } catch (Dali::DaliException e) {
13921       {
13922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13923       };
13924     } catch (...) {
13925       {
13926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13927       };
13928     }
13929   }
13930
13931   jresult = result;
13932   return jresult;
13933 }
13934
13935
13936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13937   unsigned int jresult ;
13938   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13939   bool result;
13940
13941   arg1 = (Dali::Matrix3 *)jarg1;
13942   {
13943     try {
13944       result = (bool)(arg1)->ScaledInverseTranspose();
13945     } catch (std::out_of_range& e) {
13946       {
13947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13948       };
13949     } catch (std::exception& e) {
13950       {
13951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13952       };
13953     } catch (Dali::DaliException e) {
13954       {
13955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13956       };
13957     } catch (...) {
13958       {
13959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13960       };
13961     }
13962   }
13963
13964   jresult = result;
13965   return jresult;
13966 }
13967
13968
13969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13970   Dali::Matrix3 *arg1 = 0 ;
13971   Dali::Matrix3 *arg2 = 0 ;
13972   Dali::Matrix3 *arg3 = 0 ;
13973
13974   arg1 = (Dali::Matrix3 *)jarg1;
13975   if (!arg1) {
13976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13977     return ;
13978   }
13979   arg2 = (Dali::Matrix3 *)jarg2;
13980   if (!arg2) {
13981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13982     return ;
13983   }
13984   arg3 = (Dali::Matrix3 *)jarg3;
13985   if (!arg3) {
13986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13987     return ;
13988   }
13989   {
13990     try {
13991       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13992     } catch (std::out_of_range& e) {
13993       {
13994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13995       };
13996     } catch (std::exception& e) {
13997       {
13998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13999       };
14000     } catch (Dali::DaliException e) {
14001       {
14002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14003       };
14004     } catch (...) {
14005       {
14006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14007       };
14008     }
14009   }
14010
14011 }
14012
14013
14014 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14015   float jresult ;
14016   float arg1 ;
14017   float arg2 ;
14018   float result;
14019
14020   arg1 = (float)jarg1;
14021   arg2 = (float)jarg2;
14022   {
14023     try {
14024       result = (float)Dali::Random::Range(arg1,arg2);
14025     } catch (std::out_of_range& e) {
14026       {
14027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14028       };
14029     } catch (std::exception& e) {
14030       {
14031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14032       };
14033     } catch (Dali::DaliException e) {
14034       {
14035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14036       };
14037     } catch (...) {
14038       {
14039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14040       };
14041     }
14042   }
14043
14044   jresult = result;
14045   return jresult;
14046 }
14047
14048
14049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14050   void * jresult ;
14051   Dali::Vector4 result;
14052
14053   {
14054     try {
14055       result = Dali::Random::Axis();
14056     } catch (std::out_of_range& e) {
14057       {
14058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14059       };
14060     } catch (std::exception& e) {
14061       {
14062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14063       };
14064     } catch (Dali::DaliException e) {
14065       {
14066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14067       };
14068     } catch (...) {
14069       {
14070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14071       };
14072     }
14073   }
14074
14075   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14076   return jresult;
14077 }
14078
14079
14080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14081   void * jresult ;
14082   Dali::AngleAxis *result = 0 ;
14083
14084   {
14085     try {
14086       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14087     } catch (std::out_of_range& e) {
14088       {
14089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14090       };
14091     } catch (std::exception& e) {
14092       {
14093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14094       };
14095     } catch (Dali::DaliException e) {
14096       {
14097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14098       };
14099     } catch (...) {
14100       {
14101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14102       };
14103     }
14104   }
14105
14106   jresult = (void *)result;
14107   return jresult;
14108 }
14109
14110
14111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14112   void * jresult ;
14113   Dali::Radian arg1 ;
14114   Dali::Vector3 *arg2 = 0 ;
14115   Dali::Radian *argp1 ;
14116   Dali::AngleAxis *result = 0 ;
14117
14118   argp1 = (Dali::Radian *)jarg1;
14119   if (!argp1) {
14120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14121     return 0;
14122   }
14123   arg1 = *argp1;
14124   arg2 = (Dali::Vector3 *)jarg2;
14125   if (!arg2) {
14126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14127     return 0;
14128   }
14129   {
14130     try {
14131       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14132     } catch (std::out_of_range& e) {
14133       {
14134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14135       };
14136     } catch (std::exception& e) {
14137       {
14138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14139       };
14140     } catch (Dali::DaliException e) {
14141       {
14142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14143       };
14144     } catch (...) {
14145       {
14146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14147       };
14148     }
14149   }
14150
14151   jresult = (void *)result;
14152   return jresult;
14153 }
14154
14155
14156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14157   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14158   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14159
14160   arg1 = (Dali::AngleAxis *)jarg1;
14161   arg2 = (Dali::Radian *)jarg2;
14162   if (arg1) (arg1)->angle = *arg2;
14163 }
14164
14165
14166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14167   void * jresult ;
14168   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14169   Dali::Radian *result = 0 ;
14170
14171   arg1 = (Dali::AngleAxis *)jarg1;
14172   result = (Dali::Radian *)& ((arg1)->angle);
14173   jresult = (void *)result;
14174   return jresult;
14175 }
14176
14177
14178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14179   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14180   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14181
14182   arg1 = (Dali::AngleAxis *)jarg1;
14183   arg2 = (Dali::Vector3 *)jarg2;
14184   if (arg1) (arg1)->axis = *arg2;
14185 }
14186
14187
14188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14189   void * jresult ;
14190   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14191   Dali::Vector3 *result = 0 ;
14192
14193   arg1 = (Dali::AngleAxis *)jarg1;
14194   result = (Dali::Vector3 *)& ((arg1)->axis);
14195   jresult = (void *)result;
14196   return jresult;
14197 }
14198
14199
14200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14201   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14202
14203   arg1 = (Dali::AngleAxis *)jarg1;
14204   {
14205     try {
14206       delete arg1;
14207     } catch (std::out_of_range& e) {
14208       {
14209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14210       };
14211     } catch (std::exception& e) {
14212       {
14213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14214       };
14215     } catch (Dali::DaliException e) {
14216       {
14217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14218       };
14219     } catch (...) {
14220       {
14221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14222       };
14223     }
14224   }
14225
14226 }
14227
14228
14229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14230   unsigned int jresult ;
14231   Dali::AngleAxis *arg1 = 0 ;
14232   Dali::AngleAxis *arg2 = 0 ;
14233   bool result;
14234
14235   arg1 = (Dali::AngleAxis *)jarg1;
14236   if (!arg1) {
14237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14238     return 0;
14239   }
14240   arg2 = (Dali::AngleAxis *)jarg2;
14241   if (!arg2) {
14242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14243     return 0;
14244   }
14245   {
14246     try {
14247       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14248     } catch (std::out_of_range& e) {
14249       {
14250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14251       };
14252     } catch (std::exception& e) {
14253       {
14254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14255       };
14256     } catch (Dali::DaliException e) {
14257       {
14258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14259       };
14260     } catch (...) {
14261       {
14262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14263       };
14264     }
14265   }
14266
14267   jresult = result;
14268   return jresult;
14269 }
14270
14271
14272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14273   unsigned int jresult ;
14274   unsigned int arg1 ;
14275   unsigned int result;
14276
14277   arg1 = (unsigned int)jarg1;
14278   {
14279     try {
14280       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14281     } catch (std::out_of_range& e) {
14282       {
14283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14284       };
14285     } catch (std::exception& e) {
14286       {
14287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14288       };
14289     } catch (Dali::DaliException e) {
14290       {
14291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14292       };
14293     } catch (...) {
14294       {
14295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14296       };
14297     }
14298   }
14299
14300   jresult = result;
14301   return jresult;
14302 }
14303
14304
14305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14306   unsigned int jresult ;
14307   unsigned int arg1 ;
14308   bool result;
14309
14310   arg1 = (unsigned int)jarg1;
14311   {
14312     try {
14313       result = (bool)Dali::IsPowerOfTwo(arg1);
14314     } catch (std::out_of_range& e) {
14315       {
14316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14317       };
14318     } catch (std::exception& e) {
14319       {
14320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14321       };
14322     } catch (Dali::DaliException e) {
14323       {
14324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14325       };
14326     } catch (...) {
14327       {
14328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14329       };
14330     }
14331   }
14332
14333   jresult = result;
14334   return jresult;
14335 }
14336
14337
14338 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14339   float jresult ;
14340   float arg1 ;
14341   float arg2 ;
14342   float result;
14343
14344   arg1 = (float)jarg1;
14345   arg2 = (float)jarg2;
14346   {
14347     try {
14348       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14349     } catch (std::out_of_range& e) {
14350       {
14351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14352       };
14353     } catch (std::exception& e) {
14354       {
14355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14356       };
14357     } catch (Dali::DaliException e) {
14358       {
14359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14360       };
14361     } catch (...) {
14362       {
14363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14364       };
14365     }
14366   }
14367
14368   jresult = result;
14369   return jresult;
14370 }
14371
14372
14373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14374   unsigned int jresult ;
14375   float arg1 ;
14376   bool result;
14377
14378   arg1 = (float)jarg1;
14379   {
14380     try {
14381       result = (bool)Dali::EqualsZero(arg1);
14382     } catch (std::out_of_range& e) {
14383       {
14384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14385       };
14386     } catch (std::exception& e) {
14387       {
14388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14389       };
14390     } catch (Dali::DaliException e) {
14391       {
14392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14393       };
14394     } catch (...) {
14395       {
14396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14397       };
14398     }
14399   }
14400
14401   jresult = result;
14402   return jresult;
14403 }
14404
14405
14406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14407   unsigned int jresult ;
14408   float arg1 ;
14409   float arg2 ;
14410   bool result;
14411
14412   arg1 = (float)jarg1;
14413   arg2 = (float)jarg2;
14414   {
14415     try {
14416       result = (bool)Dali::Equals(arg1,arg2);
14417     } catch (std::out_of_range& e) {
14418       {
14419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14420       };
14421     } catch (std::exception& e) {
14422       {
14423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14424       };
14425     } catch (Dali::DaliException e) {
14426       {
14427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14428       };
14429     } catch (...) {
14430       {
14431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14432       };
14433     }
14434   }
14435
14436   jresult = result;
14437   return jresult;
14438 }
14439
14440
14441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14442   unsigned int jresult ;
14443   float arg1 ;
14444   float arg2 ;
14445   float arg3 ;
14446   bool result;
14447
14448   arg1 = (float)jarg1;
14449   arg2 = (float)jarg2;
14450   arg3 = (float)jarg3;
14451   {
14452     try {
14453       result = (bool)Dali::Equals(arg1,arg2,arg3);
14454     } catch (std::out_of_range& e) {
14455       {
14456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14457       };
14458     } catch (std::exception& e) {
14459       {
14460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14461       };
14462     } catch (Dali::DaliException e) {
14463       {
14464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14465       };
14466     } catch (...) {
14467       {
14468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14469       };
14470     }
14471   }
14472
14473   jresult = result;
14474   return jresult;
14475 }
14476
14477
14478 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14479   float jresult ;
14480   float arg1 ;
14481   int arg2 ;
14482   float result;
14483
14484   arg1 = (float)jarg1;
14485   arg2 = (int)jarg2;
14486   {
14487     try {
14488       result = (float)Dali::Round(arg1,arg2);
14489     } catch (std::out_of_range& e) {
14490       {
14491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14492       };
14493     } catch (std::exception& e) {
14494       {
14495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14496       };
14497     } catch (Dali::DaliException e) {
14498       {
14499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14500       };
14501     } catch (...) {
14502       {
14503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14504       };
14505     }
14506   }
14507
14508   jresult = result;
14509   return jresult;
14510 }
14511
14512
14513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14514   float jresult ;
14515   float arg1 ;
14516   float arg2 ;
14517   float arg3 ;
14518   float result;
14519
14520   arg1 = (float)jarg1;
14521   arg2 = (float)jarg2;
14522   arg3 = (float)jarg3;
14523   {
14524     try {
14525       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14526     } catch (std::out_of_range& e) {
14527       {
14528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14529       };
14530     } catch (std::exception& e) {
14531       {
14532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14533       };
14534     } catch (Dali::DaliException e) {
14535       {
14536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14537       };
14538     } catch (...) {
14539       {
14540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14541       };
14542     }
14543   }
14544
14545   jresult = result;
14546   return jresult;
14547 }
14548
14549
14550 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14551   float jresult ;
14552   float arg1 ;
14553   float arg2 ;
14554   float arg3 ;
14555   float arg4 ;
14556   float result;
14557
14558   arg1 = (float)jarg1;
14559   arg2 = (float)jarg2;
14560   arg3 = (float)jarg3;
14561   arg4 = (float)jarg4;
14562   {
14563     try {
14564       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14565     } catch (std::out_of_range& e) {
14566       {
14567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14568       };
14569     } catch (std::exception& e) {
14570       {
14571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14572       };
14573     } catch (Dali::DaliException e) {
14574       {
14575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14576       };
14577     } catch (...) {
14578       {
14579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14580       };
14581     }
14582   }
14583
14584   jresult = result;
14585   return jresult;
14586 }
14587
14588
14589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14590   int jresult ;
14591   int result;
14592
14593   result = (int)(int)Dali::Property::INVALID_INDEX;
14594   jresult = result;
14595   return jresult;
14596 }
14597
14598
14599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14600   int jresult ;
14601   int result;
14602
14603   result = (int)(int)Dali::Property::INVALID_KEY;
14604   jresult = result;
14605   return jresult;
14606 }
14607
14608
14609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14610   int jresult ;
14611   int result;
14612
14613   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14614   jresult = result;
14615   return jresult;
14616 }
14617
14618
14619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14620   void * jresult ;
14621   Dali::Handle *arg1 = 0 ;
14622   Dali::Property::Index arg2 ;
14623   Dali::Property *result = 0 ;
14624
14625   arg1 = (Dali::Handle *)jarg1;
14626   if (!arg1) {
14627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14628     return 0;
14629   }
14630   arg2 = (Dali::Property::Index)jarg2;
14631   {
14632     try {
14633       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14634     } catch (std::out_of_range& e) {
14635       {
14636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14637       };
14638     } catch (std::exception& e) {
14639       {
14640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14641       };
14642     } catch (Dali::DaliException e) {
14643       {
14644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14645       };
14646     } catch (...) {
14647       {
14648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14649       };
14650     }
14651   }
14652
14653   jresult = (void *)result;
14654   return jresult;
14655 }
14656
14657
14658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14659   void * jresult ;
14660   Dali::Handle *arg1 = 0 ;
14661   Dali::Property::Index arg2 ;
14662   int arg3 ;
14663   Dali::Property *result = 0 ;
14664
14665   arg1 = (Dali::Handle *)jarg1;
14666   if (!arg1) {
14667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14668     return 0;
14669   }
14670   arg2 = (Dali::Property::Index)jarg2;
14671   arg3 = (int)jarg3;
14672   {
14673     try {
14674       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14675     } catch (std::out_of_range& e) {
14676       {
14677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14678       };
14679     } catch (std::exception& e) {
14680       {
14681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14682       };
14683     } catch (Dali::DaliException e) {
14684       {
14685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14686       };
14687     } catch (...) {
14688       {
14689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14690       };
14691     }
14692   }
14693
14694   jresult = (void *)result;
14695   return jresult;
14696 }
14697
14698
14699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14700   void * jresult ;
14701   Dali::Handle *arg1 = 0 ;
14702   std::string *arg2 = 0 ;
14703   Dali::Property *result = 0 ;
14704
14705   arg1 = (Dali::Handle *)jarg1;
14706   if (!arg1) {
14707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14708     return 0;
14709   }
14710   if (!jarg2) {
14711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14712     return 0;
14713   }
14714   std::string arg2_str(jarg2);
14715   arg2 = &arg2_str;
14716   {
14717     try {
14718       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14719     } catch (std::out_of_range& e) {
14720       {
14721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14722       };
14723     } catch (std::exception& e) {
14724       {
14725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14726       };
14727     } catch (Dali::DaliException e) {
14728       {
14729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14730       };
14731     } catch (...) {
14732       {
14733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14734       };
14735     }
14736   }
14737
14738   jresult = (void *)result;
14739
14740   //argout typemap for const std::string&
14741
14742   return jresult;
14743 }
14744
14745
14746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14747   void * jresult ;
14748   Dali::Handle *arg1 = 0 ;
14749   std::string *arg2 = 0 ;
14750   int arg3 ;
14751   Dali::Property *result = 0 ;
14752
14753   arg1 = (Dali::Handle *)jarg1;
14754   if (!arg1) {
14755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14756     return 0;
14757   }
14758   if (!jarg2) {
14759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14760     return 0;
14761   }
14762   std::string arg2_str(jarg2);
14763   arg2 = &arg2_str;
14764   arg3 = (int)jarg3;
14765   {
14766     try {
14767       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14768     } catch (std::out_of_range& e) {
14769       {
14770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14771       };
14772     } catch (std::exception& e) {
14773       {
14774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14775       };
14776     } catch (Dali::DaliException e) {
14777       {
14778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14779       };
14780     } catch (...) {
14781       {
14782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14783       };
14784     }
14785   }
14786
14787   jresult = (void *)result;
14788
14789   //argout typemap for const std::string&
14790
14791   return jresult;
14792 }
14793
14794
14795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14796   Dali::Property *arg1 = (Dali::Property *) 0 ;
14797
14798   arg1 = (Dali::Property *)jarg1;
14799   {
14800     try {
14801       delete arg1;
14802     } catch (std::out_of_range& e) {
14803       {
14804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14805       };
14806     } catch (std::exception& e) {
14807       {
14808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14809       };
14810     } catch (Dali::DaliException e) {
14811       {
14812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14813       };
14814     } catch (...) {
14815       {
14816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14817       };
14818     }
14819   }
14820
14821 }
14822
14823
14824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14825   Dali::Property *arg1 = (Dali::Property *) 0 ;
14826   Dali::Handle *arg2 = 0 ;
14827
14828   arg1 = (Dali::Property *)jarg1;
14829   arg2 = (Dali::Handle *)jarg2;
14830   if (!arg2) {
14831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14832     return ;
14833   }
14834   if (arg1) (arg1)->object = *arg2;
14835 }
14836
14837
14838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14839   void * jresult ;
14840   Dali::Property *arg1 = (Dali::Property *) 0 ;
14841   Dali::Handle *result = 0 ;
14842
14843   arg1 = (Dali::Property *)jarg1;
14844   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14845   jresult = (void *)result;
14846   return jresult;
14847 }
14848
14849
14850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14851   Dali::Property *arg1 = (Dali::Property *) 0 ;
14852   Dali::Property::Index arg2 ;
14853
14854   arg1 = (Dali::Property *)jarg1;
14855   arg2 = (Dali::Property::Index)jarg2;
14856   if (arg1) (arg1)->propertyIndex = arg2;
14857 }
14858
14859
14860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14861   int jresult ;
14862   Dali::Property *arg1 = (Dali::Property *) 0 ;
14863   Dali::Property::Index result;
14864
14865   arg1 = (Dali::Property *)jarg1;
14866   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14867   jresult = result;
14868   return jresult;
14869 }
14870
14871
14872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14873   Dali::Property *arg1 = (Dali::Property *) 0 ;
14874   int arg2 ;
14875
14876   arg1 = (Dali::Property *)jarg1;
14877   arg2 = (int)jarg2;
14878   if (arg1) (arg1)->componentIndex = arg2;
14879 }
14880
14881
14882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14883   int jresult ;
14884   Dali::Property *arg1 = (Dali::Property *) 0 ;
14885   int result;
14886
14887   arg1 = (Dali::Property *)jarg1;
14888   result = (int) ((arg1)->componentIndex);
14889   jresult = result;
14890   return jresult;
14891 }
14892
14893
14894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14895   void * jresult ;
14896   Dali::Property::Array *result = 0 ;
14897
14898   {
14899     try {
14900       result = (Dali::Property::Array *)new Dali::Property::Array();
14901     } catch (std::out_of_range& e) {
14902       {
14903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14904       };
14905     } catch (std::exception& e) {
14906       {
14907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14908       };
14909     } catch (Dali::DaliException e) {
14910       {
14911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14912       };
14913     } catch (...) {
14914       {
14915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14916       };
14917     }
14918   }
14919
14920   jresult = (void *)result;
14921   return jresult;
14922 }
14923
14924
14925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14926   void * jresult ;
14927   Dali::Property::Array *arg1 = 0 ;
14928   Dali::Property::Array *result = 0 ;
14929
14930   arg1 = (Dali::Property::Array *)jarg1;
14931   if (!arg1) {
14932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14933     return 0;
14934   }
14935   {
14936     try {
14937       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14938     } catch (std::out_of_range& e) {
14939       {
14940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14941       };
14942     } catch (std::exception& e) {
14943       {
14944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14945       };
14946     } catch (Dali::DaliException e) {
14947       {
14948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14949       };
14950     } catch (...) {
14951       {
14952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14953       };
14954     }
14955   }
14956
14957   jresult = (void *)result;
14958   return jresult;
14959 }
14960
14961
14962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14963   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14964
14965   arg1 = (Dali::Property::Array *)jarg1;
14966   {
14967     try {
14968       delete arg1;
14969     } catch (std::out_of_range& e) {
14970       {
14971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14972       };
14973     } catch (std::exception& e) {
14974       {
14975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14976       };
14977     } catch (Dali::DaliException e) {
14978       {
14979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14980       };
14981     } catch (...) {
14982       {
14983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14984       };
14985     }
14986   }
14987
14988 }
14989
14990
14991 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14992   unsigned long jresult ;
14993   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14994   Dali::Property::Array::SizeType result;
14995
14996   arg1 = (Dali::Property::Array *)jarg1;
14997   {
14998     try {
14999       result = ((Dali::Property::Array const *)arg1)->Size();
15000     } catch (std::out_of_range& e) {
15001       {
15002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15003       };
15004     } catch (std::exception& e) {
15005       {
15006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15007       };
15008     } catch (Dali::DaliException e) {
15009       {
15010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15011       };
15012     } catch (...) {
15013       {
15014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15015       };
15016     }
15017   }
15018
15019   jresult = (unsigned long)result;
15020   return jresult;
15021 }
15022
15023
15024 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15025   unsigned long jresult ;
15026   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15027   Dali::Property::Array::SizeType result;
15028
15029   arg1 = (Dali::Property::Array *)jarg1;
15030   {
15031     try {
15032       result = ((Dali::Property::Array const *)arg1)->Count();
15033     } catch (std::out_of_range& e) {
15034       {
15035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15036       };
15037     } catch (std::exception& e) {
15038       {
15039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15040       };
15041     } catch (Dali::DaliException e) {
15042       {
15043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15044       };
15045     } catch (...) {
15046       {
15047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15048       };
15049     }
15050   }
15051
15052   jresult = (unsigned long)result;
15053   return jresult;
15054 }
15055
15056
15057 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15058   unsigned int jresult ;
15059   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15060   bool result;
15061
15062   arg1 = (Dali::Property::Array *)jarg1;
15063   {
15064     try {
15065       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15066     } catch (std::out_of_range& e) {
15067       {
15068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15069       };
15070     } catch (std::exception& e) {
15071       {
15072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15073       };
15074     } catch (Dali::DaliException e) {
15075       {
15076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15077       };
15078     } catch (...) {
15079       {
15080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15081       };
15082     }
15083   }
15084
15085   jresult = result;
15086   return jresult;
15087 }
15088
15089
15090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15091   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15092
15093   arg1 = (Dali::Property::Array *)jarg1;
15094   {
15095     try {
15096       (arg1)->Clear();
15097     } catch (std::out_of_range& e) {
15098       {
15099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15100       };
15101     } catch (std::exception& e) {
15102       {
15103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15104       };
15105     } catch (Dali::DaliException e) {
15106       {
15107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15108       };
15109     } catch (...) {
15110       {
15111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15112       };
15113     }
15114   }
15115
15116 }
15117
15118
15119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15120   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15121   Dali::Property::Array::SizeType arg2 ;
15122
15123   arg1 = (Dali::Property::Array *)jarg1;
15124   arg2 = (Dali::Property::Array::SizeType)jarg2;
15125   {
15126     try {
15127       (arg1)->Reserve(arg2);
15128     } catch (std::out_of_range& e) {
15129       {
15130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15131       };
15132     } catch (std::exception& e) {
15133       {
15134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15135       };
15136     } catch (Dali::DaliException e) {
15137       {
15138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15139       };
15140     } catch (...) {
15141       {
15142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15143       };
15144     }
15145   }
15146
15147 }
15148
15149
15150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15151   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15152   Dali::Property::Array::SizeType arg2 ;
15153
15154   arg1 = (Dali::Property::Array *)jarg1;
15155   arg2 = (Dali::Property::Array::SizeType)jarg2;
15156   {
15157     try {
15158       (arg1)->Resize(arg2);
15159     } catch (std::out_of_range& e) {
15160       {
15161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15162       };
15163     } catch (std::exception& e) {
15164       {
15165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15166       };
15167     } catch (Dali::DaliException e) {
15168       {
15169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15170       };
15171     } catch (...) {
15172       {
15173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15174       };
15175     }
15176   }
15177
15178 }
15179
15180
15181 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15182   unsigned long jresult ;
15183   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15184   Dali::Property::Array::SizeType result;
15185
15186   arg1 = (Dali::Property::Array *)jarg1;
15187   {
15188     try {
15189       result = (arg1)->Capacity();
15190     } catch (std::out_of_range& e) {
15191       {
15192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15193       };
15194     } catch (std::exception& e) {
15195       {
15196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15197       };
15198     } catch (Dali::DaliException e) {
15199       {
15200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15201       };
15202     } catch (...) {
15203       {
15204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15205       };
15206     }
15207   }
15208
15209   jresult = (unsigned long)result;
15210   return jresult;
15211 }
15212
15213
15214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15215   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15216   Dali::Property::Value *arg2 = 0 ;
15217
15218   arg1 = (Dali::Property::Array *)jarg1;
15219   arg2 = (Dali::Property::Value *)jarg2;
15220   if (!arg2) {
15221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15222     return ;
15223   }
15224   {
15225     try {
15226       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15227     } catch (std::out_of_range& e) {
15228       {
15229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15230       };
15231     } catch (std::exception& e) {
15232       {
15233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15234       };
15235     } catch (Dali::DaliException e) {
15236       {
15237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15238       };
15239     } catch (...) {
15240       {
15241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15242       };
15243     }
15244   }
15245
15246 }
15247
15248
15249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15250   void * jresult ;
15251   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15252   Dali::Property::Value *arg2 = 0 ;
15253   Dali::Property::Array *result = 0 ;
15254
15255   arg1 = (Dali::Property::Array *)jarg1;
15256   arg2 = (Dali::Property::Value *)jarg2;
15257   if (!arg2) {
15258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15259     return 0;
15260   }
15261   {
15262     try {
15263       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15264     } catch (std::out_of_range& e) {
15265       {
15266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15267       };
15268     } catch (std::exception& e) {
15269       {
15270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15271       };
15272     } catch (Dali::DaliException e) {
15273       {
15274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15275       };
15276     } catch (...) {
15277       {
15278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15279       };
15280     }
15281   }
15282
15283   jresult = (void *)result;
15284   return jresult;
15285 }
15286
15287
15288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15289   void * jresult ;
15290   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15291   Dali::Property::Array::SizeType arg2 ;
15292   Dali::Property::Value *result = 0 ;
15293
15294   arg1 = (Dali::Property::Array *)jarg1;
15295   arg2 = (Dali::Property::Array::SizeType)jarg2;
15296   {
15297     try {
15298       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15299     } catch (std::out_of_range& e) {
15300       {
15301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15302       };
15303     } catch (std::exception& e) {
15304       {
15305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15306       };
15307     } catch (Dali::DaliException e) {
15308       {
15309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15310       };
15311     } catch (...) {
15312       {
15313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15314       };
15315     }
15316   }
15317
15318   jresult = (void *)result;
15319   return jresult;
15320 }
15321
15322
15323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15324   void * jresult ;
15325   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15326   Dali::Property::Array::SizeType arg2 ;
15327   Dali::Property::Value *result = 0 ;
15328
15329   arg1 = (Dali::Property::Array *)jarg1;
15330   arg2 = (Dali::Property::Array::SizeType)jarg2;
15331   {
15332     try {
15333       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15334     } catch (std::out_of_range& e) {
15335       {
15336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15337       };
15338     } catch (std::exception& e) {
15339       {
15340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15341       };
15342     } catch (Dali::DaliException e) {
15343       {
15344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15345       };
15346     } catch (...) {
15347       {
15348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15349       };
15350     }
15351   }
15352
15353   jresult = (void *)result;
15354   return jresult;
15355 }
15356
15357
15358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15359   void * jresult ;
15360   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15361   Dali::Property::Array *arg2 = 0 ;
15362   Dali::Property::Array *result = 0 ;
15363
15364   arg1 = (Dali::Property::Array *)jarg1;
15365   arg2 = (Dali::Property::Array *)jarg2;
15366   if (!arg2) {
15367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15368     return 0;
15369   }
15370   {
15371     try {
15372       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15373     } catch (std::out_of_range& e) {
15374       {
15375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15376       };
15377     } catch (std::exception& e) {
15378       {
15379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15380       };
15381     } catch (Dali::DaliException e) {
15382       {
15383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15384       };
15385     } catch (...) {
15386       {
15387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15388       };
15389     }
15390   }
15391
15392   jresult = (void *)result;
15393   return jresult;
15394 }
15395
15396
15397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15398   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15399   enum Dali::Property::Key::Type arg2 ;
15400
15401   arg1 = (Dali::Property::Key *)jarg1;
15402   arg2 = (enum Dali::Property::Key::Type)jarg2;
15403   if (arg1) (arg1)->type = arg2;
15404 }
15405
15406
15407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15408   int jresult ;
15409   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15410   enum Dali::Property::Key::Type result;
15411
15412   arg1 = (Dali::Property::Key *)jarg1;
15413   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15414   jresult = (int)result;
15415   return jresult;
15416 }
15417
15418
15419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15420   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15421   Dali::Property::Index arg2 ;
15422
15423   arg1 = (Dali::Property::Key *)jarg1;
15424   arg2 = (Dali::Property::Index)jarg2;
15425   if (arg1) (arg1)->indexKey = arg2;
15426 }
15427
15428
15429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15430   int jresult ;
15431   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15432   Dali::Property::Index result;
15433
15434   arg1 = (Dali::Property::Key *)jarg1;
15435   result = (Dali::Property::Index) ((arg1)->indexKey);
15436   jresult = result;
15437   return jresult;
15438 }
15439
15440
15441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15442   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15443   std::string *arg2 = 0 ;
15444
15445   arg1 = (Dali::Property::Key *)jarg1;
15446   if (!jarg2) {
15447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15448     return ;
15449   }
15450   std::string arg2_str(jarg2);
15451   arg2 = &arg2_str;
15452   if (arg1) (arg1)->stringKey = *arg2;
15453
15454   //argout typemap for const std::string&
15455
15456 }
15457
15458
15459 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15460   char * jresult ;
15461   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15462   std::string *result = 0 ;
15463
15464   arg1 = (Dali::Property::Key *)jarg1;
15465   result = (std::string *) & ((arg1)->stringKey);
15466   jresult = SWIG_csharp_string_callback(result->c_str());
15467   return jresult;
15468 }
15469
15470
15471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15472   void * jresult ;
15473   std::string *arg1 = 0 ;
15474   Dali::Property::Key *result = 0 ;
15475
15476   if (!jarg1) {
15477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15478     return 0;
15479   }
15480   std::string arg1_str(jarg1);
15481   arg1 = &arg1_str;
15482   {
15483     try {
15484       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15485     } catch (std::out_of_range& e) {
15486       {
15487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15488       };
15489     } catch (std::exception& e) {
15490       {
15491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15492       };
15493     } catch (Dali::DaliException e) {
15494       {
15495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15496       };
15497     } catch (...) {
15498       {
15499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15500       };
15501     }
15502   }
15503
15504   jresult = (void *)result;
15505
15506   //argout typemap for const std::string&
15507
15508   return jresult;
15509 }
15510
15511
15512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15513   void * jresult ;
15514   Dali::Property::Index arg1 ;
15515   Dali::Property::Key *result = 0 ;
15516
15517   arg1 = (Dali::Property::Index)jarg1;
15518   {
15519     try {
15520       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15521     } catch (std::out_of_range& e) {
15522       {
15523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15524       };
15525     } catch (std::exception& e) {
15526       {
15527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15528       };
15529     } catch (Dali::DaliException e) {
15530       {
15531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15532       };
15533     } catch (...) {
15534       {
15535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15536       };
15537     }
15538   }
15539
15540   jresult = (void *)result;
15541   return jresult;
15542 }
15543
15544
15545 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15546   unsigned int jresult ;
15547   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15548   std::string *arg2 = 0 ;
15549   bool result;
15550
15551   arg1 = (Dali::Property::Key *)jarg1;
15552   if (!jarg2) {
15553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15554     return 0;
15555   }
15556   std::string arg2_str(jarg2);
15557   arg2 = &arg2_str;
15558   {
15559     try {
15560       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15561     } catch (std::out_of_range& e) {
15562       {
15563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15564       };
15565     } catch (std::exception& e) {
15566       {
15567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15568       };
15569     } catch (Dali::DaliException e) {
15570       {
15571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15572       };
15573     } catch (...) {
15574       {
15575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15576       };
15577     }
15578   }
15579
15580   jresult = result;
15581
15582   //argout typemap for const std::string&
15583
15584   return jresult;
15585 }
15586
15587
15588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15589   unsigned int jresult ;
15590   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15591   Dali::Property::Index arg2 ;
15592   bool result;
15593
15594   arg1 = (Dali::Property::Key *)jarg1;
15595   arg2 = (Dali::Property::Index)jarg2;
15596   {
15597     try {
15598       result = (bool)(arg1)->operator ==(arg2);
15599     } catch (std::out_of_range& e) {
15600       {
15601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15602       };
15603     } catch (std::exception& e) {
15604       {
15605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15606       };
15607     } catch (Dali::DaliException e) {
15608       {
15609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15610       };
15611     } catch (...) {
15612       {
15613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15614       };
15615     }
15616   }
15617
15618   jresult = result;
15619   return jresult;
15620 }
15621
15622
15623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15624   unsigned int jresult ;
15625   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15626   Dali::Property::Key *arg2 = 0 ;
15627   bool result;
15628
15629   arg1 = (Dali::Property::Key *)jarg1;
15630   arg2 = (Dali::Property::Key *)jarg2;
15631   if (!arg2) {
15632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15633     return 0;
15634   }
15635   {
15636     try {
15637       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15638     } catch (std::out_of_range& e) {
15639       {
15640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15641       };
15642     } catch (std::exception& e) {
15643       {
15644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15645       };
15646     } catch (Dali::DaliException e) {
15647       {
15648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15649       };
15650     } catch (...) {
15651       {
15652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15653       };
15654     }
15655   }
15656
15657   jresult = result;
15658   return jresult;
15659 }
15660
15661
15662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15663   unsigned int jresult ;
15664   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15665   std::string *arg2 = 0 ;
15666   bool result;
15667
15668   arg1 = (Dali::Property::Key *)jarg1;
15669   if (!jarg2) {
15670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15671     return 0;
15672   }
15673   std::string arg2_str(jarg2);
15674   arg2 = &arg2_str;
15675   {
15676     try {
15677       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15678     } catch (std::out_of_range& e) {
15679       {
15680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15681       };
15682     } catch (std::exception& e) {
15683       {
15684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15685       };
15686     } catch (Dali::DaliException e) {
15687       {
15688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15689       };
15690     } catch (...) {
15691       {
15692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15693       };
15694     }
15695   }
15696
15697   jresult = result;
15698
15699   //argout typemap for const std::string&
15700
15701   return jresult;
15702 }
15703
15704
15705 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15706   unsigned int jresult ;
15707   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15708   Dali::Property::Index arg2 ;
15709   bool result;
15710
15711   arg1 = (Dali::Property::Key *)jarg1;
15712   arg2 = (Dali::Property::Index)jarg2;
15713   {
15714     try {
15715       result = (bool)(arg1)->operator !=(arg2);
15716     } catch (std::out_of_range& e) {
15717       {
15718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15719       };
15720     } catch (std::exception& e) {
15721       {
15722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15723       };
15724     } catch (Dali::DaliException e) {
15725       {
15726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15727       };
15728     } catch (...) {
15729       {
15730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15731       };
15732     }
15733   }
15734
15735   jresult = result;
15736   return jresult;
15737 }
15738
15739
15740 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15741   unsigned int jresult ;
15742   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15743   Dali::Property::Key *arg2 = 0 ;
15744   bool result;
15745
15746   arg1 = (Dali::Property::Key *)jarg1;
15747   arg2 = (Dali::Property::Key *)jarg2;
15748   if (!arg2) {
15749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15750     return 0;
15751   }
15752   {
15753     try {
15754       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15755     } catch (std::out_of_range& e) {
15756       {
15757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15758       };
15759     } catch (std::exception& e) {
15760       {
15761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15762       };
15763     } catch (Dali::DaliException e) {
15764       {
15765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15766       };
15767     } catch (...) {
15768       {
15769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15770       };
15771     }
15772   }
15773
15774   jresult = result;
15775   return jresult;
15776 }
15777
15778
15779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15780   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15781
15782   arg1 = (Dali::Property::Key *)jarg1;
15783   {
15784     try {
15785       delete arg1;
15786     } catch (std::out_of_range& e) {
15787       {
15788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15789       };
15790     } catch (std::exception& e) {
15791       {
15792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15793       };
15794     } catch (Dali::DaliException e) {
15795       {
15796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15797       };
15798     } catch (...) {
15799       {
15800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15801       };
15802     }
15803   }
15804
15805 }
15806
15807
15808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15809   void * jresult ;
15810   Dali::Property::Map *result = 0 ;
15811
15812   {
15813     try {
15814       result = (Dali::Property::Map *)new Dali::Property::Map();
15815     } catch (std::out_of_range& e) {
15816       {
15817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15818       };
15819     } catch (std::exception& e) {
15820       {
15821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15822       };
15823     } catch (Dali::DaliException e) {
15824       {
15825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15826       };
15827     } catch (...) {
15828       {
15829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15830       };
15831     }
15832   }
15833
15834   jresult = (void *)result;
15835   return jresult;
15836 }
15837
15838
15839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15840   void * jresult ;
15841   Dali::Property::Map *arg1 = 0 ;
15842   Dali::Property::Map *result = 0 ;
15843
15844   arg1 = (Dali::Property::Map *)jarg1;
15845   if (!arg1) {
15846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15847     return 0;
15848   }
15849   {
15850     try {
15851       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15852     } catch (std::out_of_range& e) {
15853       {
15854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15855       };
15856     } catch (std::exception& e) {
15857       {
15858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15859       };
15860     } catch (Dali::DaliException e) {
15861       {
15862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15863       };
15864     } catch (...) {
15865       {
15866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15867       };
15868     }
15869   }
15870
15871   jresult = (void *)result;
15872   return jresult;
15873 }
15874
15875
15876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15877   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15878
15879   arg1 = (Dali::Property::Map *)jarg1;
15880   {
15881     try {
15882       delete arg1;
15883     } catch (std::out_of_range& e) {
15884       {
15885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15886       };
15887     } catch (std::exception& e) {
15888       {
15889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15890       };
15891     } catch (Dali::DaliException e) {
15892       {
15893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15894       };
15895     } catch (...) {
15896       {
15897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15898       };
15899     }
15900   }
15901
15902 }
15903
15904
15905 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15906   unsigned long jresult ;
15907   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15908   Dali::Property::Map::SizeType result;
15909
15910   arg1 = (Dali::Property::Map *)jarg1;
15911   {
15912     try {
15913       result = ((Dali::Property::Map const *)arg1)->Count();
15914     } catch (std::out_of_range& e) {
15915       {
15916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15917       };
15918     } catch (std::exception& e) {
15919       {
15920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15921       };
15922     } catch (Dali::DaliException e) {
15923       {
15924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15925       };
15926     } catch (...) {
15927       {
15928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15929       };
15930     }
15931   }
15932
15933   jresult = (unsigned long)result;
15934   return jresult;
15935 }
15936
15937
15938 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15939   unsigned int jresult ;
15940   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15941   bool result;
15942
15943   arg1 = (Dali::Property::Map *)jarg1;
15944   {
15945     try {
15946       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15947     } catch (std::out_of_range& e) {
15948       {
15949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15950       };
15951     } catch (std::exception& e) {
15952       {
15953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15954       };
15955     } catch (Dali::DaliException e) {
15956       {
15957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15958       };
15959     } catch (...) {
15960       {
15961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15962       };
15963     }
15964   }
15965
15966   jresult = result;
15967   return jresult;
15968 }
15969
15970
15971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15972   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15973   char *arg2 = (char *) 0 ;
15974   Dali::Property::Value *arg3 = 0 ;
15975
15976   arg1 = (Dali::Property::Map *)jarg1;
15977   arg2 = (char *)jarg2;
15978   arg3 = (Dali::Property::Value *)jarg3;
15979   if (!arg3) {
15980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15981     return ;
15982   }
15983   {
15984     try {
15985       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15986     } catch (std::out_of_range& e) {
15987       {
15988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15989       };
15990     } catch (std::exception& e) {
15991       {
15992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15993       };
15994     } catch (Dali::DaliException e) {
15995       {
15996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15997       };
15998     } catch (...) {
15999       {
16000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16001       };
16002     }
16003   }
16004
16005 }
16006
16007
16008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16009   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16010   Dali::Property::Index arg2 ;
16011   Dali::Property::Value *arg3 = 0 ;
16012
16013   arg1 = (Dali::Property::Map *)jarg1;
16014   arg2 = (Dali::Property::Index)jarg2;
16015   arg3 = (Dali::Property::Value *)jarg3;
16016   if (!arg3) {
16017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16018     return ;
16019   }
16020   {
16021     try {
16022       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16023     } catch (std::out_of_range& e) {
16024       {
16025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16026       };
16027     } catch (std::exception& e) {
16028       {
16029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16030       };
16031     } catch (Dali::DaliException e) {
16032       {
16033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16034       };
16035     } catch (...) {
16036       {
16037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16038       };
16039     }
16040   }
16041
16042 }
16043
16044
16045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16046   void * jresult ;
16047   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16048   char *arg2 = (char *) 0 ;
16049   Dali::Property::Value *arg3 = 0 ;
16050   Dali::Property::Map *result = 0 ;
16051
16052   arg1 = (Dali::Property::Map *)jarg1;
16053   arg2 = (char *)jarg2;
16054   arg3 = (Dali::Property::Value *)jarg3;
16055   if (!arg3) {
16056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16057     return 0;
16058   }
16059   {
16060     try {
16061       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16062     } catch (std::out_of_range& e) {
16063       {
16064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16065       };
16066     } catch (std::exception& e) {
16067       {
16068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16069       };
16070     } catch (Dali::DaliException e) {
16071       {
16072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16073       };
16074     } catch (...) {
16075       {
16076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16077       };
16078     }
16079   }
16080
16081   jresult = (void *)result;
16082   return jresult;
16083 }
16084
16085
16086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16087   void * jresult ;
16088   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16089   Dali::Property::Index arg2 ;
16090   Dali::Property::Value *arg3 = 0 ;
16091   Dali::Property::Map *result = 0 ;
16092
16093   arg1 = (Dali::Property::Map *)jarg1;
16094   arg2 = (Dali::Property::Index)jarg2;
16095   arg3 = (Dali::Property::Value *)jarg3;
16096   if (!arg3) {
16097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16098     return 0;
16099   }
16100   {
16101     try {
16102       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16103     } catch (std::out_of_range& e) {
16104       {
16105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16106       };
16107     } catch (std::exception& e) {
16108       {
16109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16110       };
16111     } catch (Dali::DaliException e) {
16112       {
16113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16114       };
16115     } catch (...) {
16116       {
16117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16118       };
16119     }
16120   }
16121
16122   jresult = (void *)result;
16123   return jresult;
16124 }
16125
16126
16127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16128   void * jresult ;
16129   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16130   Dali::Property::Map::SizeType arg2 ;
16131   Dali::Property::Value *result = 0 ;
16132
16133   arg1 = (Dali::Property::Map *)jarg1;
16134   arg2 = (Dali::Property::Map::SizeType)jarg2;
16135   {
16136     try {
16137       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16138     } catch (std::out_of_range& e) {
16139       {
16140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16141       };
16142     } catch (std::exception& e) {
16143       {
16144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16145       };
16146     } catch (Dali::DaliException e) {
16147       {
16148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16149       };
16150     } catch (...) {
16151       {
16152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16153       };
16154     }
16155   }
16156
16157   jresult = (void *)result;
16158   return jresult;
16159 }
16160
16161
16162 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16163   char * jresult ;
16164   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16165   Dali::Property::Map::SizeType arg2 ;
16166   std::string *result = 0 ;
16167
16168   arg1 = (Dali::Property::Map *)jarg1;
16169   arg2 = (Dali::Property::Map::SizeType)jarg2;
16170   {
16171     try {
16172       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16173     } catch (std::out_of_range& e) {
16174       {
16175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16176       };
16177     } catch (std::exception& e) {
16178       {
16179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16180       };
16181     } catch (Dali::DaliException e) {
16182       {
16183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16184       };
16185     } catch (...) {
16186       {
16187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16188       };
16189     }
16190   }
16191
16192   jresult = SWIG_csharp_string_callback(result->c_str());
16193   return jresult;
16194 }
16195
16196
16197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16198   void * jresult ;
16199   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16200   Dali::Property::Map::SizeType arg2 ;
16201   SwigValueWrapper< Dali::Property::Key > result;
16202
16203   arg1 = (Dali::Property::Map *)jarg1;
16204   arg2 = (Dali::Property::Map::SizeType)jarg2;
16205   {
16206     try {
16207       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16208     } catch (std::out_of_range& e) {
16209       {
16210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16211       };
16212     } catch (std::exception& e) {
16213       {
16214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16215       };
16216     } catch (Dali::DaliException e) {
16217       {
16218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16219       };
16220     } catch (...) {
16221       {
16222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16223       };
16224     }
16225   }
16226
16227   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16228   return jresult;
16229 }
16230
16231
16232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16233   void * jresult ;
16234   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16235   Dali::Property::Map::SizeType arg2 ;
16236   StringValuePair *result = 0 ;
16237
16238   arg1 = (Dali::Property::Map *)jarg1;
16239   arg2 = (Dali::Property::Map::SizeType)jarg2;
16240   {
16241     try {
16242       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16243     } catch (std::out_of_range& e) {
16244       {
16245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16246       };
16247     } catch (std::exception& e) {
16248       {
16249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16250       };
16251     } catch (Dali::DaliException e) {
16252       {
16253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16254       };
16255     } catch (...) {
16256       {
16257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16258       };
16259     }
16260   }
16261
16262   jresult = (void *)result;
16263   return jresult;
16264 }
16265
16266
16267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16268   void * jresult ;
16269   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16270   char *arg2 = (char *) 0 ;
16271   Dali::Property::Value *result = 0 ;
16272
16273   arg1 = (Dali::Property::Map *)jarg1;
16274   arg2 = (char *)jarg2;
16275   {
16276     try {
16277       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16278     } catch (std::out_of_range& e) {
16279       {
16280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16281       };
16282     } catch (std::exception& e) {
16283       {
16284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16285       };
16286     } catch (Dali::DaliException e) {
16287       {
16288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16289       };
16290     } catch (...) {
16291       {
16292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16293       };
16294     }
16295   }
16296
16297   jresult = (void *)result;
16298   return jresult;
16299 }
16300
16301
16302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16303   void * jresult ;
16304   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16305   Dali::Property::Index arg2 ;
16306   Dali::Property::Value *result = 0 ;
16307
16308   arg1 = (Dali::Property::Map *)jarg1;
16309   arg2 = (Dali::Property::Index)jarg2;
16310   {
16311     try {
16312       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16313     } catch (std::out_of_range& e) {
16314       {
16315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16316       };
16317     } catch (std::exception& e) {
16318       {
16319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16320       };
16321     } catch (Dali::DaliException e) {
16322       {
16323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16324       };
16325     } catch (...) {
16326       {
16327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16328       };
16329     }
16330   }
16331
16332   jresult = (void *)result;
16333   return jresult;
16334 }
16335
16336
16337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16338   void * jresult ;
16339   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16340   Dali::Property::Index arg2 ;
16341   std::string *arg3 = 0 ;
16342   Dali::Property::Value *result = 0 ;
16343
16344   arg1 = (Dali::Property::Map *)jarg1;
16345   arg2 = (Dali::Property::Index)jarg2;
16346   if (!jarg3) {
16347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16348     return 0;
16349   }
16350   std::string arg3_str(jarg3);
16351   arg3 = &arg3_str;
16352   {
16353     try {
16354       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16355     } catch (std::out_of_range& e) {
16356       {
16357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16358       };
16359     } catch (std::exception& e) {
16360       {
16361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16362       };
16363     } catch (Dali::DaliException e) {
16364       {
16365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16366       };
16367     } catch (...) {
16368       {
16369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16370       };
16371     }
16372   }
16373
16374   jresult = (void *)result;
16375
16376   //argout typemap for const std::string&
16377
16378   return jresult;
16379 }
16380
16381
16382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16383   void * jresult ;
16384   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16385   std::string *arg2 = 0 ;
16386   Dali::Property::Type arg3 ;
16387   Dali::Property::Value *result = 0 ;
16388
16389   arg1 = (Dali::Property::Map *)jarg1;
16390   if (!jarg2) {
16391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16392     return 0;
16393   }
16394   std::string arg2_str(jarg2);
16395   arg2 = &arg2_str;
16396   arg3 = (Dali::Property::Type)jarg3;
16397   {
16398     try {
16399       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16400     } catch (std::out_of_range& e) {
16401       {
16402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16403       };
16404     } catch (std::exception& e) {
16405       {
16406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16407       };
16408     } catch (Dali::DaliException e) {
16409       {
16410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16411       };
16412     } catch (...) {
16413       {
16414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16415       };
16416     }
16417   }
16418
16419   jresult = (void *)result;
16420
16421   //argout typemap for const std::string&
16422
16423   return jresult;
16424 }
16425
16426
16427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16428   void * jresult ;
16429   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16430   Dali::Property::Index arg2 ;
16431   Dali::Property::Type arg3 ;
16432   Dali::Property::Value *result = 0 ;
16433
16434   arg1 = (Dali::Property::Map *)jarg1;
16435   arg2 = (Dali::Property::Index)jarg2;
16436   arg3 = (Dali::Property::Type)jarg3;
16437   {
16438     try {
16439       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16440     } catch (std::out_of_range& e) {
16441       {
16442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16443       };
16444     } catch (std::exception& e) {
16445       {
16446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16447       };
16448     } catch (Dali::DaliException e) {
16449       {
16450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16451       };
16452     } catch (...) {
16453       {
16454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16455       };
16456     }
16457   }
16458
16459   jresult = (void *)result;
16460   return jresult;
16461 }
16462
16463
16464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16465   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16466
16467   arg1 = (Dali::Property::Map *)jarg1;
16468   {
16469     try {
16470       (arg1)->Clear();
16471     } catch (std::out_of_range& e) {
16472       {
16473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16474       };
16475     } catch (std::exception& e) {
16476       {
16477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16478       };
16479     } catch (Dali::DaliException e) {
16480       {
16481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16482       };
16483     } catch (...) {
16484       {
16485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16486       };
16487     }
16488   }
16489
16490 }
16491
16492
16493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16494   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16495   Dali::Property::Map *arg2 = 0 ;
16496
16497   arg1 = (Dali::Property::Map *)jarg1;
16498   arg2 = (Dali::Property::Map *)jarg2;
16499   if (!arg2) {
16500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16501     return ;
16502   }
16503   {
16504     try {
16505       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16506     } catch (std::out_of_range& e) {
16507       {
16508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16509       };
16510     } catch (std::exception& e) {
16511       {
16512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16513       };
16514     } catch (Dali::DaliException e) {
16515       {
16516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16517       };
16518     } catch (...) {
16519       {
16520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16521       };
16522     }
16523   }
16524
16525 }
16526
16527
16528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16529   void * jresult ;
16530   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16531   std::string *arg2 = 0 ;
16532   Dali::Property::Value *result = 0 ;
16533
16534   arg1 = (Dali::Property::Map *)jarg1;
16535   if (!jarg2) {
16536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16537     return 0;
16538   }
16539   std::string arg2_str(jarg2);
16540   arg2 = &arg2_str;
16541   {
16542     try {
16543       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16544     } catch (std::out_of_range& e) {
16545       {
16546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16547       };
16548     } catch (std::exception& e) {
16549       {
16550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16551       };
16552     } catch (Dali::DaliException e) {
16553       {
16554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16555       };
16556     } catch (...) {
16557       {
16558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16559       };
16560     }
16561   }
16562
16563   jresult = (void *)result;
16564
16565   //argout typemap for const std::string&
16566
16567   return jresult;
16568 }
16569
16570
16571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16572   void * jresult ;
16573   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16574   Dali::Property::Index arg2 ;
16575   Dali::Property::Value *result = 0 ;
16576
16577   arg1 = (Dali::Property::Map *)jarg1;
16578   arg2 = (Dali::Property::Index)jarg2;
16579   {
16580     try {
16581       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16582     } catch (std::out_of_range& e) {
16583       {
16584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16585       };
16586     } catch (std::exception& e) {
16587       {
16588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16589       };
16590     } catch (Dali::DaliException e) {
16591       {
16592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16593       };
16594     } catch (...) {
16595       {
16596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16597       };
16598     }
16599   }
16600
16601   jresult = (void *)result;
16602   return jresult;
16603 }
16604
16605
16606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16607   void * jresult ;
16608   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16609   Dali::Property::Map *arg2 = 0 ;
16610   Dali::Property::Map *result = 0 ;
16611
16612   arg1 = (Dali::Property::Map *)jarg1;
16613   arg2 = (Dali::Property::Map *)jarg2;
16614   if (!arg2) {
16615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16616     return 0;
16617   }
16618   {
16619     try {
16620       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16621     } catch (std::out_of_range& e) {
16622       {
16623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16624       };
16625     } catch (std::exception& e) {
16626       {
16627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16628       };
16629     } catch (Dali::DaliException e) {
16630       {
16631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16632       };
16633     } catch (...) {
16634       {
16635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16636       };
16637     }
16638   }
16639
16640   jresult = (void *)result;
16641   return jresult;
16642 }
16643
16644
16645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16646   void * jresult ;
16647   Dali::Property::Value *result = 0 ;
16648
16649   {
16650     try {
16651       result = (Dali::Property::Value *)new Dali::Property::Value();
16652     } catch (std::out_of_range& e) {
16653       {
16654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16655       };
16656     } catch (std::exception& e) {
16657       {
16658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16659       };
16660     } catch (Dali::DaliException e) {
16661       {
16662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16663       };
16664     } catch (...) {
16665       {
16666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16667       };
16668     }
16669   }
16670
16671   jresult = (void *)result;
16672   return jresult;
16673 }
16674
16675
16676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16677   void * jresult ;
16678   bool arg1 ;
16679   Dali::Property::Value *result = 0 ;
16680
16681   arg1 = jarg1 ? true : false;
16682   {
16683     try {
16684       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16685     } catch (std::out_of_range& e) {
16686       {
16687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16688       };
16689     } catch (std::exception& e) {
16690       {
16691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16692       };
16693     } catch (Dali::DaliException e) {
16694       {
16695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16696       };
16697     } catch (...) {
16698       {
16699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16700       };
16701     }
16702   }
16703
16704   jresult = (void *)result;
16705   return jresult;
16706 }
16707
16708
16709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16710   void * jresult ;
16711   int arg1 ;
16712   Dali::Property::Value *result = 0 ;
16713
16714   arg1 = (int)jarg1;
16715   {
16716     try {
16717       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16718     } catch (std::out_of_range& e) {
16719       {
16720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16721       };
16722     } catch (std::exception& e) {
16723       {
16724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16725       };
16726     } catch (Dali::DaliException e) {
16727       {
16728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16729       };
16730     } catch (...) {
16731       {
16732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16733       };
16734     }
16735   }
16736
16737   jresult = (void *)result;
16738   return jresult;
16739 }
16740
16741
16742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16743   void * jresult ;
16744   float arg1 ;
16745   Dali::Property::Value *result = 0 ;
16746
16747   arg1 = (float)jarg1;
16748   {
16749     try {
16750       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16751     } catch (std::out_of_range& e) {
16752       {
16753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16754       };
16755     } catch (std::exception& e) {
16756       {
16757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16758       };
16759     } catch (Dali::DaliException e) {
16760       {
16761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16762       };
16763     } catch (...) {
16764       {
16765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16766       };
16767     }
16768   }
16769
16770   jresult = (void *)result;
16771   return jresult;
16772 }
16773
16774
16775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16776   void * jresult ;
16777   Dali::Vector2 *arg1 = 0 ;
16778   Dali::Property::Value *result = 0 ;
16779
16780   arg1 = (Dali::Vector2 *)jarg1;
16781   if (!arg1) {
16782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16783     return 0;
16784   }
16785   {
16786     try {
16787       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16788     } catch (std::out_of_range& e) {
16789       {
16790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16791       };
16792     } catch (std::exception& e) {
16793       {
16794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16795       };
16796     } catch (Dali::DaliException e) {
16797       {
16798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16799       };
16800     } catch (...) {
16801       {
16802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16803       };
16804     }
16805   }
16806
16807   jresult = (void *)result;
16808   return jresult;
16809 }
16810
16811
16812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16813   void * jresult ;
16814   Dali::Vector3 *arg1 = 0 ;
16815   Dali::Property::Value *result = 0 ;
16816
16817   arg1 = (Dali::Vector3 *)jarg1;
16818   if (!arg1) {
16819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16820     return 0;
16821   }
16822   {
16823     try {
16824       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16825     } catch (std::out_of_range& e) {
16826       {
16827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16828       };
16829     } catch (std::exception& e) {
16830       {
16831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16832       };
16833     } catch (Dali::DaliException e) {
16834       {
16835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16836       };
16837     } catch (...) {
16838       {
16839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16840       };
16841     }
16842   }
16843
16844   jresult = (void *)result;
16845   return jresult;
16846 }
16847
16848
16849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16850   void * jresult ;
16851   Dali::Vector4 *arg1 = 0 ;
16852   Dali::Property::Value *result = 0 ;
16853
16854   arg1 = (Dali::Vector4 *)jarg1;
16855   if (!arg1) {
16856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16857     return 0;
16858   }
16859   {
16860     try {
16861       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16862     } catch (std::out_of_range& e) {
16863       {
16864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16865       };
16866     } catch (std::exception& e) {
16867       {
16868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16869       };
16870     } catch (Dali::DaliException e) {
16871       {
16872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16873       };
16874     } catch (...) {
16875       {
16876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16877       };
16878     }
16879   }
16880
16881   jresult = (void *)result;
16882   return jresult;
16883 }
16884
16885
16886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16887   void * jresult ;
16888   Dali::Matrix3 *arg1 = 0 ;
16889   Dali::Property::Value *result = 0 ;
16890
16891   arg1 = (Dali::Matrix3 *)jarg1;
16892   if (!arg1) {
16893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16894     return 0;
16895   }
16896   {
16897     try {
16898       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16899     } catch (std::out_of_range& e) {
16900       {
16901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16902       };
16903     } catch (std::exception& e) {
16904       {
16905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16906       };
16907     } catch (Dali::DaliException e) {
16908       {
16909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16910       };
16911     } catch (...) {
16912       {
16913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16914       };
16915     }
16916   }
16917
16918   jresult = (void *)result;
16919   return jresult;
16920 }
16921
16922
16923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16924   void * jresult ;
16925   Dali::Matrix *arg1 = 0 ;
16926   Dali::Property::Value *result = 0 ;
16927
16928   arg1 = (Dali::Matrix *)jarg1;
16929   if (!arg1) {
16930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16931     return 0;
16932   }
16933   {
16934     try {
16935       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16936     } catch (std::out_of_range& e) {
16937       {
16938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16939       };
16940     } catch (std::exception& e) {
16941       {
16942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16943       };
16944     } catch (Dali::DaliException e) {
16945       {
16946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16947       };
16948     } catch (...) {
16949       {
16950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16951       };
16952     }
16953   }
16954
16955   jresult = (void *)result;
16956   return jresult;
16957 }
16958
16959
16960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16961   void * jresult ;
16962   Dali::Rect< int > *arg1 = 0 ;
16963   Dali::Property::Value *result = 0 ;
16964
16965   arg1 = (Dali::Rect< int > *)jarg1;
16966   if (!arg1) {
16967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16968     return 0;
16969   }
16970   {
16971     try {
16972       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16973     } catch (std::out_of_range& e) {
16974       {
16975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16976       };
16977     } catch (std::exception& e) {
16978       {
16979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16980       };
16981     } catch (Dali::DaliException e) {
16982       {
16983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16984       };
16985     } catch (...) {
16986       {
16987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16988       };
16989     }
16990   }
16991
16992   jresult = (void *)result;
16993   return jresult;
16994 }
16995
16996
16997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16998   void * jresult ;
16999   Dali::AngleAxis *arg1 = 0 ;
17000   Dali::Property::Value *result = 0 ;
17001
17002   arg1 = (Dali::AngleAxis *)jarg1;
17003   if (!arg1) {
17004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17005     return 0;
17006   }
17007   {
17008     try {
17009       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17010     } catch (std::out_of_range& e) {
17011       {
17012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17013       };
17014     } catch (std::exception& e) {
17015       {
17016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17017       };
17018     } catch (Dali::DaliException e) {
17019       {
17020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17021       };
17022     } catch (...) {
17023       {
17024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17025       };
17026     }
17027   }
17028
17029   jresult = (void *)result;
17030   return jresult;
17031 }
17032
17033
17034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17035   void * jresult ;
17036   Dali::Quaternion *arg1 = 0 ;
17037   Dali::Property::Value *result = 0 ;
17038
17039   arg1 = (Dali::Quaternion *)jarg1;
17040   if (!arg1) {
17041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17042     return 0;
17043   }
17044   {
17045     try {
17046       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17047     } catch (std::out_of_range& e) {
17048       {
17049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17050       };
17051     } catch (std::exception& e) {
17052       {
17053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17054       };
17055     } catch (Dali::DaliException e) {
17056       {
17057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17058       };
17059     } catch (...) {
17060       {
17061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17062       };
17063     }
17064   }
17065
17066   jresult = (void *)result;
17067   return jresult;
17068 }
17069
17070
17071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17072   void * jresult ;
17073   std::string *arg1 = 0 ;
17074   Dali::Property::Value *result = 0 ;
17075
17076   if (!jarg1) {
17077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17078     return 0;
17079   }
17080   std::string arg1_str(jarg1);
17081   arg1 = &arg1_str;
17082   {
17083     try {
17084       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17085     } catch (std::out_of_range& e) {
17086       {
17087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17088       };
17089     } catch (std::exception& e) {
17090       {
17091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17092       };
17093     } catch (Dali::DaliException e) {
17094       {
17095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17096       };
17097     } catch (...) {
17098       {
17099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17100       };
17101     }
17102   }
17103
17104   jresult = (void *)result;
17105
17106   //argout typemap for const std::string&
17107
17108   return jresult;
17109 }
17110
17111
17112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17113   void * jresult ;
17114   Dali::Property::Array *arg1 = 0 ;
17115   Dali::Property::Value *result = 0 ;
17116
17117   arg1 = (Dali::Property::Array *)jarg1;
17118   if (!arg1) {
17119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17120     return 0;
17121   }
17122   {
17123     try {
17124       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17125     } catch (std::out_of_range& e) {
17126       {
17127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17128       };
17129     } catch (std::exception& e) {
17130       {
17131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17132       };
17133     } catch (Dali::DaliException e) {
17134       {
17135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17136       };
17137     } catch (...) {
17138       {
17139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17140       };
17141     }
17142   }
17143
17144   jresult = (void *)result;
17145   return jresult;
17146 }
17147
17148
17149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17150   void * jresult ;
17151   Dali::Property::Map *arg1 = 0 ;
17152   Dali::Property::Value *result = 0 ;
17153
17154   arg1 = (Dali::Property::Map *)jarg1;
17155   if (!arg1) {
17156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17157     return 0;
17158   }
17159   {
17160     try {
17161       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17162     } catch (std::out_of_range& e) {
17163       {
17164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17165       };
17166     } catch (std::exception& e) {
17167       {
17168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17169       };
17170     } catch (Dali::DaliException e) {
17171       {
17172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17173       };
17174     } catch (...) {
17175       {
17176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17177       };
17178     }
17179   }
17180
17181   jresult = (void *)result;
17182   return jresult;
17183 }
17184
17185
17186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17187   void * jresult ;
17188   Extents *arg1 = 0 ;
17189   Dali::Property::Value *result = 0 ;
17190
17191   arg1 = (Extents *)jarg1;
17192   if (!arg1) {
17193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17194     return 0;
17195   }
17196   {
17197     try {
17198       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17199     } catch (std::out_of_range& e) {
17200       {
17201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17202       };
17203     } catch (std::exception& e) {
17204       {
17205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17206       };
17207     } catch (...) {
17208       {
17209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17210       };
17211     }
17212   }
17213   jresult = (void *)result;
17214   return jresult;
17215 }
17216
17217
17218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17219   void * jresult ;
17220   Dali::Property::Type arg1 ;
17221   Dali::Property::Value *result = 0 ;
17222
17223   arg1 = (Dali::Property::Type)jarg1;
17224   {
17225     try {
17226       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17227     } catch (std::out_of_range& e) {
17228       {
17229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17230       };
17231     } catch (std::exception& e) {
17232       {
17233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17234       };
17235     } catch (Dali::DaliException e) {
17236       {
17237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17238       };
17239     } catch (...) {
17240       {
17241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17242       };
17243     }
17244   }
17245
17246   jresult = (void *)result;
17247   return jresult;
17248 }
17249
17250
17251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17252   void * jresult ;
17253   Dali::Property::Value *arg1 = 0 ;
17254   Dali::Property::Value *result = 0 ;
17255
17256   arg1 = (Dali::Property::Value *)jarg1;
17257   if (!arg1) {
17258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17259     return 0;
17260   }
17261   {
17262     try {
17263       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17264     } catch (std::out_of_range& e) {
17265       {
17266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17267       };
17268     } catch (std::exception& e) {
17269       {
17270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17271       };
17272     } catch (Dali::DaliException e) {
17273       {
17274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17275       };
17276     } catch (...) {
17277       {
17278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17279       };
17280     }
17281   }
17282
17283   jresult = (void *)result;
17284   return jresult;
17285 }
17286
17287
17288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17289   void * jresult ;
17290   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17291   Dali::Property::Value *arg2 = 0 ;
17292   Dali::Property::Value *result = 0 ;
17293
17294   arg1 = (Dali::Property::Value *)jarg1;
17295   arg2 = (Dali::Property::Value *)jarg2;
17296   if (!arg2) {
17297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17298     return 0;
17299   }
17300   {
17301     try {
17302       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17303     } catch (std::out_of_range& e) {
17304       {
17305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17306       };
17307     } catch (std::exception& e) {
17308       {
17309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17310       };
17311     } catch (Dali::DaliException e) {
17312       {
17313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17314       };
17315     } catch (...) {
17316       {
17317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17318       };
17319     }
17320   }
17321
17322   jresult = (void *)result;
17323   return jresult;
17324 }
17325
17326
17327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17328   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17329
17330   arg1 = (Dali::Property::Value *)jarg1;
17331   {
17332     try {
17333       delete arg1;
17334     } catch (std::out_of_range& e) {
17335       {
17336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17337       };
17338     } catch (std::exception& e) {
17339       {
17340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17341       };
17342     } catch (Dali::DaliException e) {
17343       {
17344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17345       };
17346     } catch (...) {
17347       {
17348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17349       };
17350     }
17351   }
17352
17353 }
17354
17355
17356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17357   int jresult ;
17358   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17359   Dali::Property::Type result;
17360
17361   arg1 = (Dali::Property::Value *)jarg1;
17362   {
17363     try {
17364       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17365     } catch (std::out_of_range& e) {
17366       {
17367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17368       };
17369     } catch (std::exception& e) {
17370       {
17371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17372       };
17373     } catch (Dali::DaliException e) {
17374       {
17375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17376       };
17377     } catch (...) {
17378       {
17379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17380       };
17381     }
17382   }
17383
17384   jresult = (int)result;
17385   return jresult;
17386 }
17387
17388
17389 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17390   unsigned int jresult ;
17391   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17392   bool *arg2 = 0 ;
17393   bool result;
17394
17395   arg1 = (Dali::Property::Value *)jarg1;
17396   arg2 = (bool *)jarg2;
17397   {
17398     try {
17399       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17400     } catch (std::out_of_range& e) {
17401       {
17402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17403       };
17404     } catch (std::exception& e) {
17405       {
17406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17407       };
17408     } catch (Dali::DaliException e) {
17409       {
17410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17411       };
17412     } catch (...) {
17413       {
17414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17415       };
17416     }
17417   }
17418
17419   jresult = result;
17420   return jresult;
17421 }
17422
17423
17424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17425   unsigned int jresult ;
17426   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17427   float *arg2 = 0 ;
17428   bool result;
17429
17430   arg1 = (Dali::Property::Value *)jarg1;
17431   arg2 = (float *)jarg2;
17432   {
17433     try {
17434       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17435     } catch (std::out_of_range& e) {
17436       {
17437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17438       };
17439     } catch (std::exception& e) {
17440       {
17441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17442       };
17443     } catch (Dali::DaliException e) {
17444       {
17445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17446       };
17447     } catch (...) {
17448       {
17449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17450       };
17451     }
17452   }
17453
17454   jresult = result;
17455   return jresult;
17456 }
17457
17458
17459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17460   unsigned int jresult ;
17461   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17462   int *arg2 = 0 ;
17463   bool result;
17464
17465   arg1 = (Dali::Property::Value *)jarg1;
17466   arg2 = (int *)jarg2;
17467   {
17468     try {
17469       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17470     } catch (std::out_of_range& e) {
17471       {
17472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17473       };
17474     } catch (std::exception& e) {
17475       {
17476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17477       };
17478     } catch (Dali::DaliException e) {
17479       {
17480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17481       };
17482     } catch (...) {
17483       {
17484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17485       };
17486     }
17487   }
17488
17489   jresult = result;
17490   return jresult;
17491 }
17492
17493
17494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17495   unsigned int jresult ;
17496   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17497   Dali::Rect< int > *arg2 = 0 ;
17498   bool result;
17499
17500   arg1 = (Dali::Property::Value *)jarg1;
17501   arg2 = (Dali::Rect< int > *)jarg2;
17502   if (!arg2) {
17503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17504     return 0;
17505   }
17506   {
17507     try {
17508       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17509     } catch (std::out_of_range& e) {
17510       {
17511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17512       };
17513     } catch (std::exception& e) {
17514       {
17515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17516       };
17517     } catch (Dali::DaliException e) {
17518       {
17519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17520       };
17521     } catch (...) {
17522       {
17523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17524       };
17525     }
17526   }
17527
17528   jresult = result;
17529   return jresult;
17530 }
17531
17532
17533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17534   unsigned int jresult ;
17535   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17536   Dali::Vector2 *arg2 = 0 ;
17537   bool result;
17538
17539   arg1 = (Dali::Property::Value *)jarg1;
17540   arg2 = (Dali::Vector2 *)jarg2;
17541   if (!arg2) {
17542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17543     return 0;
17544   }
17545   {
17546     try {
17547       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17548     } catch (std::out_of_range& e) {
17549       {
17550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17551       };
17552     } catch (std::exception& e) {
17553       {
17554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17555       };
17556     } catch (Dali::DaliException e) {
17557       {
17558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17559       };
17560     } catch (...) {
17561       {
17562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17563       };
17564     }
17565   }
17566
17567   jresult = result;
17568   return jresult;
17569 }
17570
17571
17572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17573   unsigned int jresult ;
17574   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17575   Dali::Vector3 *arg2 = 0 ;
17576   bool result;
17577
17578   arg1 = (Dali::Property::Value *)jarg1;
17579   arg2 = (Dali::Vector3 *)jarg2;
17580   if (!arg2) {
17581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17582     return 0;
17583   }
17584   {
17585     try {
17586       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17587     } catch (std::out_of_range& e) {
17588       {
17589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17590       };
17591     } catch (std::exception& e) {
17592       {
17593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17594       };
17595     } catch (Dali::DaliException e) {
17596       {
17597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17598       };
17599     } catch (...) {
17600       {
17601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17602       };
17603     }
17604   }
17605
17606   jresult = result;
17607   return jresult;
17608 }
17609
17610
17611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17612   unsigned int jresult ;
17613   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17614   Dali::Vector4 *arg2 = 0 ;
17615   bool result;
17616
17617   arg1 = (Dali::Property::Value *)jarg1;
17618   arg2 = (Dali::Vector4 *)jarg2;
17619   if (!arg2) {
17620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17621     return 0;
17622   }
17623   {
17624     try {
17625       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17626     } catch (std::out_of_range& e) {
17627       {
17628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17629       };
17630     } catch (std::exception& e) {
17631       {
17632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17633       };
17634     } catch (Dali::DaliException e) {
17635       {
17636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17637       };
17638     } catch (...) {
17639       {
17640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17641       };
17642     }
17643   }
17644
17645   jresult = result;
17646   return jresult;
17647 }
17648
17649
17650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17651   unsigned int jresult ;
17652   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17653   Dali::Matrix3 *arg2 = 0 ;
17654   bool result;
17655
17656   arg1 = (Dali::Property::Value *)jarg1;
17657   arg2 = (Dali::Matrix3 *)jarg2;
17658   if (!arg2) {
17659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17660     return 0;
17661   }
17662   {
17663     try {
17664       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17665     } catch (std::out_of_range& e) {
17666       {
17667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17668       };
17669     } catch (std::exception& e) {
17670       {
17671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17672       };
17673     } catch (Dali::DaliException e) {
17674       {
17675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17676       };
17677     } catch (...) {
17678       {
17679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17680       };
17681     }
17682   }
17683
17684   jresult = result;
17685   return jresult;
17686 }
17687
17688
17689 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17690   unsigned int jresult ;
17691   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17692   Dali::Matrix *arg2 = 0 ;
17693   bool result;
17694
17695   arg1 = (Dali::Property::Value *)jarg1;
17696   arg2 = (Dali::Matrix *)jarg2;
17697   if (!arg2) {
17698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17699     return 0;
17700   }
17701   {
17702     try {
17703       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17704     } catch (std::out_of_range& e) {
17705       {
17706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17707       };
17708     } catch (std::exception& e) {
17709       {
17710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17711       };
17712     } catch (Dali::DaliException e) {
17713       {
17714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17715       };
17716     } catch (...) {
17717       {
17718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17719       };
17720     }
17721   }
17722
17723   jresult = result;
17724   return jresult;
17725 }
17726
17727
17728 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17729   unsigned int jresult ;
17730   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17731   Dali::AngleAxis *arg2 = 0 ;
17732   bool result;
17733
17734   arg1 = (Dali::Property::Value *)jarg1;
17735   arg2 = (Dali::AngleAxis *)jarg2;
17736   if (!arg2) {
17737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17738     return 0;
17739   }
17740   {
17741     try {
17742       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17743     } catch (std::out_of_range& e) {
17744       {
17745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17746       };
17747     } catch (std::exception& e) {
17748       {
17749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17750       };
17751     } catch (Dali::DaliException e) {
17752       {
17753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17754       };
17755     } catch (...) {
17756       {
17757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17758       };
17759     }
17760   }
17761
17762   jresult = result;
17763   return jresult;
17764 }
17765
17766
17767 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17768   unsigned int jresult ;
17769   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17770   Dali::Quaternion *arg2 = 0 ;
17771   bool result;
17772
17773   arg1 = (Dali::Property::Value *)jarg1;
17774   arg2 = (Dali::Quaternion *)jarg2;
17775   if (!arg2) {
17776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17777     return 0;
17778   }
17779   {
17780     try {
17781       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17782     } catch (std::out_of_range& e) {
17783       {
17784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17785       };
17786     } catch (std::exception& e) {
17787       {
17788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17789       };
17790     } catch (Dali::DaliException e) {
17791       {
17792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17793       };
17794     } catch (...) {
17795       {
17796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17797       };
17798     }
17799   }
17800
17801   jresult = result;
17802   return jresult;
17803 }
17804
17805
17806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17807   unsigned int jresult ;
17808   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17809   std::string *arg2 = 0 ;
17810   bool result;
17811
17812   arg1 = (Dali::Property::Value *)jarg1;
17813
17814   //typemap in
17815   std::string temp;
17816   arg2 = &temp;
17817
17818   {
17819     try {
17820       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17821     } catch (std::out_of_range& e) {
17822       {
17823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17824       };
17825     } catch (std::exception& e) {
17826       {
17827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17828       };
17829     } catch (Dali::DaliException e) {
17830       {
17831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17832       };
17833     } catch (...) {
17834       {
17835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17836       };
17837     }
17838   }
17839
17840   jresult = result;
17841
17842   //Typemap argout in c++ file.
17843   //This will convert c++ string to c# string
17844   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17845
17846   return jresult;
17847 }
17848
17849
17850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17851   unsigned int jresult ;
17852   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17853   Dali::Property::Array *arg2 = 0 ;
17854   bool result;
17855
17856   arg1 = (Dali::Property::Value *)jarg1;
17857   arg2 = (Dali::Property::Array *)jarg2;
17858   if (!arg2) {
17859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17860     return 0;
17861   }
17862   {
17863     try {
17864       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17865     } catch (std::out_of_range& e) {
17866       {
17867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17868       };
17869     } catch (std::exception& e) {
17870       {
17871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17872       };
17873     } catch (Dali::DaliException e) {
17874       {
17875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17876       };
17877     } catch (...) {
17878       {
17879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17880       };
17881     }
17882   }
17883
17884   jresult = result;
17885   return jresult;
17886 }
17887
17888
17889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17890   unsigned int jresult ;
17891   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17892   Dali::Property::Map *arg2 = 0 ;
17893   bool result;
17894
17895   arg1 = (Dali::Property::Value *)jarg1;
17896   arg2 = (Dali::Property::Map *)jarg2;
17897   if (!arg2) {
17898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17899     return 0;
17900   }
17901   {
17902     try {
17903       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17904     } catch (std::out_of_range& e) {
17905       {
17906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17907       };
17908     } catch (std::exception& e) {
17909       {
17910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17911       };
17912     } catch (Dali::DaliException e) {
17913       {
17914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17915       };
17916     } catch (...) {
17917       {
17918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17919       };
17920     }
17921   }
17922
17923   jresult = result;
17924   return jresult;
17925 }
17926
17927
17928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17929   unsigned int jresult ;
17930   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17931   Extents *arg2 = 0 ;
17932   bool result;
17933
17934   arg1 = (Dali::Property::Value *)jarg1;
17935   arg2 = (Extents *)jarg2;
17936   if (!arg2) {
17937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17938     return 0;
17939   }
17940   {
17941     try {
17942       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17943     } catch (std::out_of_range& e) {
17944       {
17945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17946       };
17947     } catch (std::exception& e) {
17948       {
17949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17950       };
17951     } catch (...) {
17952       {
17953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17954       };
17955     }
17956   }
17957   jresult = result;
17958   return jresult;
17959 }
17960
17961
17962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17963   void * jresult ;
17964   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17965   Dali::Property::Array *result = 0 ;
17966
17967   arg1 = (Dali::Property::Value *)jarg1;
17968   {
17969     try {
17970       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17971     } catch (std::out_of_range& e) {
17972       {
17973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17974       };
17975     } catch (std::exception& e) {
17976       {
17977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17978       };
17979     } catch (Dali::DaliException e) {
17980       {
17981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17982       };
17983     } catch (...) {
17984       {
17985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17986       };
17987     }
17988   }
17989
17990   jresult = (void *)result;
17991   return jresult;
17992 }
17993
17994
17995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17996   void * jresult ;
17997   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17998   Dali::Property::Map *result = 0 ;
17999
18000   arg1 = (Dali::Property::Value *)jarg1;
18001   {
18002     try {
18003       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18004     } catch (std::out_of_range& e) {
18005       {
18006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18007       };
18008     } catch (std::exception& e) {
18009       {
18010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18011       };
18012     } catch (Dali::DaliException e) {
18013       {
18014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18015       };
18016     } catch (...) {
18017       {
18018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18019       };
18020     }
18021   }
18022
18023   jresult = (void *)result;
18024   return jresult;
18025 }
18026
18027
18028 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18029   char * jresult ;
18030   Dali::Property::Type arg1 ;
18031   char *result = 0 ;
18032
18033   arg1 = (Dali::Property::Type)jarg1;
18034   {
18035     try {
18036       result = (char *)Dali::PropertyTypes::GetName(arg1);
18037     } catch (std::out_of_range& e) {
18038       {
18039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18040       };
18041     } catch (std::exception& e) {
18042       {
18043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18044       };
18045     } catch (Dali::DaliException e) {
18046       {
18047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18048       };
18049     } catch (...) {
18050       {
18051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18052       };
18053     }
18054   }
18055
18056   jresult = SWIG_csharp_string_callback((const char *)result);
18057   return jresult;
18058 }
18059
18060
18061 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18062   unsigned int jresult ;
18063   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18064   std::string *arg2 = 0 ;
18065   Dali::Property::Map *arg3 = 0 ;
18066   bool result;
18067
18068   arg1 = (Dali::BaseObject *)jarg1;
18069   if (!jarg2) {
18070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18071     return 0;
18072   }
18073   std::string arg2_str(jarg2);
18074   arg2 = &arg2_str;
18075   arg3 = (Dali::Property::Map *)jarg3;
18076   if (!arg3) {
18077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18078     return 0;
18079   }
18080   {
18081     try {
18082       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18083     } catch (std::out_of_range& e) {
18084       {
18085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18086       };
18087     } catch (std::exception& e) {
18088       {
18089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18090       };
18091     } catch (Dali::DaliException e) {
18092       {
18093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18094       };
18095     } catch (...) {
18096       {
18097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18098       };
18099     }
18100   }
18101
18102   jresult = result;
18103
18104   //argout typemap for const std::string&
18105
18106   return jresult;
18107 }
18108
18109
18110 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18111   char * jresult ;
18112   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18113   std::string *result = 0 ;
18114
18115   arg1 = (Dali::BaseObject *)jarg1;
18116   {
18117     try {
18118       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18119     } catch (std::out_of_range& e) {
18120       {
18121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18122       };
18123     } catch (std::exception& e) {
18124       {
18125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18126       };
18127     } catch (Dali::DaliException e) {
18128       {
18129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18130       };
18131     } catch (...) {
18132       {
18133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18134       };
18135     }
18136   }
18137
18138   jresult = SWIG_csharp_string_callback(result->c_str());
18139   return jresult;
18140 }
18141
18142
18143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18144   unsigned int jresult ;
18145   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18146   Dali::TypeInfo *arg2 = 0 ;
18147   bool result;
18148
18149   arg1 = (Dali::BaseObject *)jarg1;
18150   arg2 = (Dali::TypeInfo *)jarg2;
18151   if (!arg2) {
18152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18153     return 0;
18154   }
18155   {
18156     try {
18157       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18158     } catch (std::out_of_range& e) {
18159       {
18160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18161       };
18162     } catch (std::exception& e) {
18163       {
18164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18165       };
18166     } catch (Dali::DaliException e) {
18167       {
18168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18169       };
18170     } catch (...) {
18171       {
18172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18173       };
18174     }
18175   }
18176
18177   jresult = result;
18178   return jresult;
18179 }
18180
18181
18182 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18183   unsigned int jresult ;
18184   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18185   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18186   std::string *arg3 = 0 ;
18187   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18188   bool result;
18189
18190   arg1 = (Dali::BaseObject *)jarg1;
18191   arg2 = (ConnectionTrackerInterface *)jarg2;
18192   if (!jarg3) {
18193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18194     return 0;
18195   }
18196   std::string arg3_str(jarg3);
18197   arg3 = &arg3_str;
18198   arg4 = (FunctorDelegate *)jarg4;
18199   {
18200     try {
18201       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18202     } catch (std::out_of_range& e) {
18203       {
18204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18205       };
18206     } catch (std::exception& e) {
18207       {
18208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18209       };
18210     } catch (Dali::DaliException e) {
18211       {
18212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18213       };
18214     } catch (...) {
18215       {
18216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18217       };
18218     }
18219   }
18220
18221   jresult = result;
18222
18223   //argout typemap for const std::string&
18224
18225   return jresult;
18226 }
18227
18228
18229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18230   void * jresult ;
18231   Dali::BaseHandle *arg1 = 0 ;
18232   Dali::BaseObject *result = 0 ;
18233
18234   arg1 = (Dali::BaseHandle *)jarg1;
18235   if (!arg1) {
18236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18237     return 0;
18238   }
18239   {
18240     try {
18241       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18242     } catch (std::out_of_range& e) {
18243       {
18244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18245       };
18246     } catch (std::exception& e) {
18247       {
18248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18249       };
18250     } catch (Dali::DaliException e) {
18251       {
18252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18253       };
18254     } catch (...) {
18255       {
18256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18257       };
18258     }
18259   }
18260
18261   jresult = (void *)result;
18262   return jresult;
18263 }
18264
18265
18266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18267   void * jresult ;
18268   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18269   Dali::BaseHandle *result = 0 ;
18270
18271   arg1 = (Dali::BaseObject *)jarg1;
18272   {
18273     try {
18274       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18275     } catch (std::out_of_range& e) {
18276       {
18277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18278       };
18279     } catch (std::exception& e) {
18280       {
18281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18282       };
18283     } catch (Dali::DaliException e) {
18284       {
18285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18286       };
18287     } catch (...) {
18288       {
18289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18290       };
18291     }
18292   }
18293
18294   jresult = (void *)result;
18295   return jresult;
18296 }
18297
18298
18299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18300   void * jresult ;
18301   Dali::BaseHandle *result = 0 ;
18302
18303   {
18304     try {
18305       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18306     } catch (std::out_of_range& e) {
18307       {
18308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18309       };
18310     } catch (std::exception& e) {
18311       {
18312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18313       };
18314     } catch (Dali::DaliException e) {
18315       {
18316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18317       };
18318     } catch (...) {
18319       {
18320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18321       };
18322     }
18323   }
18324
18325   jresult = (void *)result;
18326   return jresult;
18327 }
18328
18329
18330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18331   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18332
18333   arg1 = (Dali::BaseHandle *)jarg1;
18334   {
18335     try {
18336       delete arg1;
18337     } catch (std::out_of_range& e) {
18338       {
18339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18340       };
18341     } catch (std::exception& e) {
18342       {
18343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18344       };
18345     } catch (Dali::DaliException e) {
18346       {
18347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18348       };
18349     } catch (...) {
18350       {
18351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18352       };
18353     }
18354   }
18355
18356 }
18357
18358
18359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18360   void * jresult ;
18361   Dali::BaseHandle *arg1 = 0 ;
18362   Dali::BaseHandle *result = 0 ;
18363
18364   arg1 = (Dali::BaseHandle *)jarg1;
18365   if (!arg1) {
18366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18367     return 0;
18368   }
18369   {
18370     try {
18371       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18372     } catch (std::out_of_range& e) {
18373       {
18374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18375       };
18376     } catch (std::exception& e) {
18377       {
18378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18379       };
18380     } catch (Dali::DaliException e) {
18381       {
18382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18383       };
18384     } catch (...) {
18385       {
18386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18387       };
18388     }
18389   }
18390
18391   jresult = (void *)result;
18392   return jresult;
18393 }
18394
18395
18396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18397   void * jresult ;
18398   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18399   Dali::BaseHandle *arg2 = 0 ;
18400   Dali::BaseHandle *result = 0 ;
18401
18402   arg1 = (Dali::BaseHandle *)jarg1;
18403   arg2 = (Dali::BaseHandle *)jarg2;
18404   if (!arg2) {
18405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18406     return 0;
18407   }
18408   {
18409     try {
18410       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18411     } catch (std::out_of_range& e) {
18412       {
18413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18414       };
18415     } catch (std::exception& e) {
18416       {
18417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18418       };
18419     } catch (Dali::DaliException e) {
18420       {
18421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18422       };
18423     } catch (...) {
18424       {
18425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18426       };
18427     }
18428   }
18429
18430   jresult = (void *)result;
18431   return jresult;
18432 }
18433
18434
18435 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18436   unsigned int jresult ;
18437   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18438   std::string *arg2 = 0 ;
18439   Dali::Property::Map *arg3 = 0 ;
18440   bool result;
18441
18442   arg1 = (Dali::BaseHandle *)jarg1;
18443   if (!jarg2) {
18444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18445     return 0;
18446   }
18447   std::string arg2_str(jarg2);
18448   arg2 = &arg2_str;
18449   arg3 = (Dali::Property::Map *)jarg3;
18450   if (!arg3) {
18451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18452     return 0;
18453   }
18454   {
18455     try {
18456       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18457     } catch (std::out_of_range& e) {
18458       {
18459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18460       };
18461     } catch (std::exception& e) {
18462       {
18463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18464       };
18465     } catch (Dali::DaliException e) {
18466       {
18467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18468       };
18469     } catch (...) {
18470       {
18471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18472       };
18473     }
18474   }
18475
18476   jresult = result;
18477
18478   //argout typemap for const std::string&
18479
18480   return jresult;
18481 }
18482
18483
18484 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18485   char * jresult ;
18486   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18487   std::string *result = 0 ;
18488
18489   arg1 = (Dali::BaseHandle *)jarg1;
18490   {
18491     try {
18492       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18493     } catch (std::out_of_range& e) {
18494       {
18495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18496       };
18497     } catch (std::exception& e) {
18498       {
18499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18500       };
18501     } catch (Dali::DaliException e) {
18502       {
18503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18504       };
18505     } catch (...) {
18506       {
18507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18508       };
18509     }
18510   }
18511
18512   jresult = SWIG_csharp_string_callback(result->c_str());
18513   return jresult;
18514 }
18515
18516
18517 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18518   unsigned int jresult ;
18519   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18520   Dali::TypeInfo *arg2 = 0 ;
18521   bool result;
18522
18523   arg1 = (Dali::BaseHandle *)jarg1;
18524   arg2 = (Dali::TypeInfo *)jarg2;
18525   if (!arg2) {
18526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18527     return 0;
18528   }
18529   {
18530     try {
18531       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18532     } catch (std::out_of_range& e) {
18533       {
18534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18535       };
18536     } catch (std::exception& e) {
18537       {
18538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18539       };
18540     } catch (Dali::DaliException e) {
18541       {
18542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18543       };
18544     } catch (...) {
18545       {
18546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18547       };
18548     }
18549   }
18550
18551   jresult = result;
18552   return jresult;
18553 }
18554
18555
18556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18557   void * jresult ;
18558   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18559   Dali::BaseObject *result = 0 ;
18560
18561   arg1 = (Dali::BaseHandle *)jarg1;
18562   {
18563     try {
18564       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18565     } catch (std::out_of_range& e) {
18566       {
18567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18568       };
18569     } catch (std::exception& e) {
18570       {
18571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18572       };
18573     } catch (Dali::DaliException e) {
18574       {
18575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18576       };
18577     } catch (...) {
18578       {
18579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18580       };
18581     }
18582   }
18583
18584   jresult = (void *)result;
18585   return jresult;
18586 }
18587
18588
18589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18590   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18591
18592   arg1 = (Dali::BaseHandle *)jarg1;
18593   {
18594     try {
18595       (arg1)->Reset();
18596     } catch (std::out_of_range& e) {
18597       {
18598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18599       };
18600     } catch (std::exception& e) {
18601       {
18602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18603       };
18604     } catch (Dali::DaliException e) {
18605       {
18606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18607       };
18608     } catch (...) {
18609       {
18610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18611       };
18612     }
18613   }
18614
18615 }
18616
18617
18618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18619   unsigned int jresult ;
18620   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18621   Dali::BaseHandle *arg2 = 0 ;
18622   bool result;
18623
18624   arg1 = (Dali::BaseHandle *)jarg1;
18625   arg2 = (Dali::BaseHandle *)jarg2;
18626   if (!arg2) {
18627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18628     return 0;
18629   }
18630   {
18631     try {
18632       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18633     } catch (std::out_of_range& e) {
18634       {
18635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18636       };
18637     } catch (std::exception& e) {
18638       {
18639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18640       };
18641     } catch (Dali::DaliException e) {
18642       {
18643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18644       };
18645     } catch (...) {
18646       {
18647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18648       };
18649     }
18650   }
18651
18652   jresult = result;
18653   return jresult;
18654 }
18655
18656
18657 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18658   unsigned int jresult ;
18659   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18660   Dali::BaseHandle *arg2 = 0 ;
18661   bool result;
18662
18663   arg1 = (Dali::BaseHandle *)jarg1;
18664   arg2 = (Dali::BaseHandle *)jarg2;
18665   if (!arg2) {
18666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18667     return 0;
18668   }
18669   {
18670     try {
18671       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18672     } catch (std::out_of_range& e) {
18673       {
18674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18675       };
18676     } catch (std::exception& e) {
18677       {
18678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18679       };
18680     } catch (Dali::DaliException e) {
18681       {
18682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18683       };
18684     } catch (...) {
18685       {
18686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18687       };
18688     }
18689   }
18690
18691   jresult = result;
18692   return jresult;
18693 }
18694
18695
18696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18697   void * jresult ;
18698   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18699   Dali::RefObject *result = 0 ;
18700
18701   arg1 = (Dali::BaseHandle *)jarg1;
18702   {
18703     try {
18704       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18705     } catch (std::out_of_range& e) {
18706       {
18707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18708       };
18709     } catch (std::exception& e) {
18710       {
18711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18712       };
18713     } catch (Dali::DaliException e) {
18714       {
18715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18716       };
18717     } catch (...) {
18718       {
18719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18720       };
18721     }
18722   }
18723
18724   jresult = (void *)result;
18725   return jresult;
18726 }
18727
18728
18729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18730   unsigned int jresult ;
18731   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18732   bool result;
18733
18734   arg1 = (Dali::BaseHandle *)jarg1;
18735   {
18736     try {
18737       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18738     } catch (std::out_of_range& e) {
18739       {
18740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18741       };
18742     } catch (std::exception& e) {
18743       {
18744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18745       };
18746     } catch (Dali::DaliException e) {
18747       {
18748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18749       };
18750     } catch (...) {
18751       {
18752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18753       };
18754     }
18755   }
18756
18757   jresult = result;
18758   return jresult;
18759 }
18760
18761
18762 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18763   unsigned int jresult ;
18764   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18765   Dali::BaseHandle *arg2 = 0 ;
18766   bool result;
18767
18768   arg1 = (Dali::BaseHandle *)jarg1;
18769   arg2 = (Dali::BaseHandle *)jarg2;
18770   if (!arg2) {
18771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18772     return 0;
18773   }
18774   {
18775     try {
18776       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18777     } catch (std::out_of_range& e) {
18778       {
18779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18780       };
18781     } catch (std::exception& e) {
18782       {
18783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18784       };
18785     } catch (Dali::DaliException e) {
18786       {
18787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18788       };
18789     } catch (...) {
18790       {
18791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18792       };
18793     }
18794   }
18795
18796   jresult = result;
18797   return jresult;
18798 }
18799
18800
18801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18802   unsigned int jresult ;
18803   Dali::BaseHandle *arg1 = 0 ;
18804   Dali::BaseHandle *arg2 = 0 ;
18805   bool result;
18806
18807   arg1 = (Dali::BaseHandle *)jarg1;
18808   if (!arg1) {
18809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18810     return 0;
18811   }
18812   arg2 = (Dali::BaseHandle *)jarg2;
18813   if (!arg2) {
18814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18815     return 0;
18816   }
18817   {
18818     try {
18819       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18820     } catch (std::out_of_range& e) {
18821       {
18822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18823       };
18824     } catch (std::exception& e) {
18825       {
18826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18827       };
18828     } catch (Dali::DaliException e) {
18829       {
18830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18831       };
18832     } catch (...) {
18833       {
18834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18835       };
18836     }
18837   }
18838
18839   jresult = result;
18840   return jresult;
18841 }
18842
18843
18844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18845   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18846
18847   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18848   {
18849     try {
18850       delete arg1;
18851     } catch (std::out_of_range& e) {
18852       {
18853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18854       };
18855     } catch (std::exception& e) {
18856       {
18857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18858       };
18859     } catch (Dali::DaliException e) {
18860       {
18861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18862       };
18863     } catch (...) {
18864       {
18865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18866       };
18867     }
18868   }
18869
18870 }
18871
18872
18873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18874   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18875   SlotObserver *arg2 = (SlotObserver *) 0 ;
18876   CallbackBase *arg3 = (CallbackBase *) 0 ;
18877
18878   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18879   arg2 = (SlotObserver *)jarg2;
18880   arg3 = (CallbackBase *)jarg3;
18881   {
18882     try {
18883       (arg1)->SignalConnected(arg2,arg3);
18884     } catch (std::out_of_range& e) {
18885       {
18886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18887       };
18888     } catch (std::exception& e) {
18889       {
18890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18891       };
18892     } catch (Dali::DaliException e) {
18893       {
18894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18895       };
18896     } catch (...) {
18897       {
18898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18899       };
18900     }
18901   }
18902
18903 }
18904
18905
18906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18907   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18908
18909   arg1 = (Dali::SignalObserver *)jarg1;
18910   {
18911     try {
18912       delete arg1;
18913     } catch (std::out_of_range& e) {
18914       {
18915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18916       };
18917     } catch (std::exception& e) {
18918       {
18919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18920       };
18921     } catch (Dali::DaliException e) {
18922       {
18923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18924       };
18925     } catch (...) {
18926       {
18927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18928       };
18929     }
18930   }
18931
18932 }
18933
18934
18935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18936   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18937   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18938   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18939
18940   arg1 = (Dali::SignalObserver *)jarg1;
18941   arg2 = (Dali::SlotObserver *)jarg2;
18942   arg3 = (Dali::CallbackBase *)jarg3;
18943   {
18944     try {
18945       (arg1)->SignalDisconnected(arg2,arg3);
18946     } catch (std::out_of_range& e) {
18947       {
18948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18949       };
18950     } catch (std::exception& e) {
18951       {
18952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18953       };
18954     } catch (Dali::DaliException e) {
18955       {
18956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18957       };
18958     } catch (...) {
18959       {
18960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18961       };
18962     }
18963   }
18964
18965 }
18966
18967
18968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18969   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18970
18971   arg1 = (Dali::SlotObserver *)jarg1;
18972   {
18973     try {
18974       delete arg1;
18975     } catch (std::out_of_range& e) {
18976       {
18977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18978       };
18979     } catch (std::exception& e) {
18980       {
18981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18982       };
18983     } catch (Dali::DaliException e) {
18984       {
18985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18986       };
18987     } catch (...) {
18988       {
18989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18990       };
18991     }
18992   }
18993
18994 }
18995
18996
18997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18998   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18999   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19000
19001   arg1 = (Dali::SlotObserver *)jarg1;
19002   arg2 = (Dali::CallbackBase *)jarg2;
19003   {
19004     try {
19005       (arg1)->SlotDisconnected(arg2);
19006     } catch (std::out_of_range& e) {
19007       {
19008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19009       };
19010     } catch (std::exception& e) {
19011       {
19012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19013       };
19014     } catch (Dali::DaliException e) {
19015       {
19016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19017       };
19018     } catch (...) {
19019       {
19020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19021       };
19022     }
19023   }
19024
19025 }
19026
19027
19028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19029   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19030
19031   arg1 = (Dali::ConnectionTracker *)jarg1;
19032   {
19033     try {
19034       delete arg1;
19035     } catch (std::out_of_range& e) {
19036       {
19037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19038       };
19039     } catch (std::exception& e) {
19040       {
19041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19042       };
19043     } catch (Dali::DaliException e) {
19044       {
19045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19046       };
19047     } catch (...) {
19048       {
19049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19050       };
19051     }
19052   }
19053
19054 }
19055
19056
19057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19058   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19059
19060   arg1 = (Dali::ConnectionTracker *)jarg1;
19061   {
19062     try {
19063       (arg1)->DisconnectAll();
19064     } catch (std::out_of_range& e) {
19065       {
19066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19067       };
19068     } catch (std::exception& e) {
19069       {
19070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19071       };
19072     } catch (Dali::DaliException e) {
19073       {
19074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19075       };
19076     } catch (...) {
19077       {
19078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19079       };
19080     }
19081   }
19082
19083 }
19084
19085
19086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19087   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19088   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19089   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19090
19091   arg1 = (Dali::ConnectionTracker *)jarg1;
19092   arg2 = (Dali::SlotObserver *)jarg2;
19093   arg3 = (Dali::CallbackBase *)jarg3;
19094   {
19095     try {
19096       (arg1)->SignalConnected(arg2,arg3);
19097     } catch (std::out_of_range& e) {
19098       {
19099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19100       };
19101     } catch (std::exception& e) {
19102       {
19103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19104       };
19105     } catch (Dali::DaliException e) {
19106       {
19107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19108       };
19109     } catch (...) {
19110       {
19111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19112       };
19113     }
19114   }
19115
19116 }
19117
19118
19119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19120   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19121   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19122   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19123
19124   arg1 = (Dali::ConnectionTracker *)jarg1;
19125   arg2 = (Dali::SlotObserver *)jarg2;
19126   arg3 = (Dali::CallbackBase *)jarg3;
19127   {
19128     try {
19129       (arg1)->SignalDisconnected(arg2,arg3);
19130     } catch (std::out_of_range& e) {
19131       {
19132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19133       };
19134     } catch (std::exception& e) {
19135       {
19136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19137       };
19138     } catch (Dali::DaliException e) {
19139       {
19140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19141       };
19142     } catch (...) {
19143       {
19144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19145       };
19146     }
19147   }
19148
19149 }
19150
19151
19152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19153   unsigned long jresult ;
19154   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19155   std::size_t result;
19156
19157   arg1 = (Dali::ConnectionTracker *)jarg1;
19158   {
19159     try {
19160       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19161     } catch (std::out_of_range& e) {
19162       {
19163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19164       };
19165     } catch (std::exception& e) {
19166       {
19167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19168       };
19169     } catch (Dali::DaliException e) {
19170       {
19171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19172       };
19173     } catch (...) {
19174       {
19175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19176       };
19177     }
19178   }
19179
19180   jresult = (unsigned long)result;
19181   return jresult;
19182 }
19183
19184
19185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19186   void * jresult ;
19187   Dali::ObjectRegistry *result = 0 ;
19188
19189   {
19190     try {
19191       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19192     } catch (std::out_of_range& e) {
19193       {
19194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19195       };
19196     } catch (std::exception& e) {
19197       {
19198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19199       };
19200     } catch (Dali::DaliException e) {
19201       {
19202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19203       };
19204     } catch (...) {
19205       {
19206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19207       };
19208     }
19209   }
19210
19211   jresult = (void *)result;
19212   return jresult;
19213 }
19214
19215
19216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19217   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19218
19219   arg1 = (Dali::ObjectRegistry *)jarg1;
19220   {
19221     try {
19222       delete arg1;
19223     } catch (std::out_of_range& e) {
19224       {
19225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19226       };
19227     } catch (std::exception& e) {
19228       {
19229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19230       };
19231     } catch (Dali::DaliException e) {
19232       {
19233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19234       };
19235     } catch (...) {
19236       {
19237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19238       };
19239     }
19240   }
19241
19242 }
19243
19244
19245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19246   void * jresult ;
19247   Dali::ObjectRegistry *arg1 = 0 ;
19248   Dali::ObjectRegistry *result = 0 ;
19249
19250   arg1 = (Dali::ObjectRegistry *)jarg1;
19251   if (!arg1) {
19252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19253     return 0;
19254   }
19255   {
19256     try {
19257       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19258     } catch (std::out_of_range& e) {
19259       {
19260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19261       };
19262     } catch (std::exception& e) {
19263       {
19264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19265       };
19266     } catch (Dali::DaliException e) {
19267       {
19268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19269       };
19270     } catch (...) {
19271       {
19272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19273       };
19274     }
19275   }
19276
19277   jresult = (void *)result;
19278   return jresult;
19279 }
19280
19281
19282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19283   void * jresult ;
19284   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19285   Dali::ObjectRegistry *arg2 = 0 ;
19286   Dali::ObjectRegistry *result = 0 ;
19287
19288   arg1 = (Dali::ObjectRegistry *)jarg1;
19289   arg2 = (Dali::ObjectRegistry *)jarg2;
19290   if (!arg2) {
19291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19292     return 0;
19293   }
19294   {
19295     try {
19296       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19297     } catch (std::out_of_range& e) {
19298       {
19299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19300       };
19301     } catch (std::exception& e) {
19302       {
19303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19304       };
19305     } catch (Dali::DaliException e) {
19306       {
19307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19308       };
19309     } catch (...) {
19310       {
19311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19312       };
19313     }
19314   }
19315
19316   jresult = (void *)result;
19317   return jresult;
19318 }
19319
19320
19321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19322   void * jresult ;
19323   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19324   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19325
19326   arg1 = (Dali::ObjectRegistry *)jarg1;
19327   {
19328     try {
19329       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19330     } catch (std::out_of_range& e) {
19331       {
19332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19333       };
19334     } catch (std::exception& e) {
19335       {
19336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19337       };
19338     } catch (Dali::DaliException e) {
19339       {
19340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19341       };
19342     } catch (...) {
19343       {
19344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19345       };
19346     }
19347   }
19348
19349   jresult = (void *)result;
19350   return jresult;
19351 }
19352
19353
19354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19355   void * jresult ;
19356   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19357   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19358
19359   arg1 = (Dali::ObjectRegistry *)jarg1;
19360   {
19361     try {
19362       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19363     } catch (std::out_of_range& e) {
19364       {
19365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19366       };
19367     } catch (std::exception& e) {
19368       {
19369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19370       };
19371     } catch (Dali::DaliException e) {
19372       {
19373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19374       };
19375     } catch (...) {
19376       {
19377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19378       };
19379     }
19380   }
19381
19382   jresult = (void *)result;
19383   return jresult;
19384 }
19385
19386
19387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19388   void * jresult ;
19389   Dali::PropertyCondition *result = 0 ;
19390
19391   {
19392     try {
19393       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19394     } catch (std::out_of_range& e) {
19395       {
19396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19397       };
19398     } catch (std::exception& e) {
19399       {
19400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19401       };
19402     } catch (Dali::DaliException e) {
19403       {
19404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19405       };
19406     } catch (...) {
19407       {
19408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19409       };
19410     }
19411   }
19412
19413   jresult = (void *)result;
19414   return jresult;
19415 }
19416
19417
19418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19419   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19420
19421   arg1 = (Dali::PropertyCondition *)jarg1;
19422   {
19423     try {
19424       delete arg1;
19425     } catch (std::out_of_range& e) {
19426       {
19427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19428       };
19429     } catch (std::exception& e) {
19430       {
19431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19432       };
19433     } catch (Dali::DaliException e) {
19434       {
19435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19436       };
19437     } catch (...) {
19438       {
19439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19440       };
19441     }
19442   }
19443
19444 }
19445
19446
19447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19448   void * jresult ;
19449   Dali::PropertyCondition *arg1 = 0 ;
19450   Dali::PropertyCondition *result = 0 ;
19451
19452   arg1 = (Dali::PropertyCondition *)jarg1;
19453   if (!arg1) {
19454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19455     return 0;
19456   }
19457   {
19458     try {
19459       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19460     } catch (std::out_of_range& e) {
19461       {
19462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19463       };
19464     } catch (std::exception& e) {
19465       {
19466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19467       };
19468     } catch (Dali::DaliException e) {
19469       {
19470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19471       };
19472     } catch (...) {
19473       {
19474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19475       };
19476     }
19477   }
19478
19479   jresult = (void *)result;
19480   return jresult;
19481 }
19482
19483
19484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19485   void * jresult ;
19486   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19487   Dali::PropertyCondition *arg2 = 0 ;
19488   Dali::PropertyCondition *result = 0 ;
19489
19490   arg1 = (Dali::PropertyCondition *)jarg1;
19491   arg2 = (Dali::PropertyCondition *)jarg2;
19492   if (!arg2) {
19493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19494     return 0;
19495   }
19496   {
19497     try {
19498       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19499     } catch (std::out_of_range& e) {
19500       {
19501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19502       };
19503     } catch (std::exception& e) {
19504       {
19505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19506       };
19507     } catch (Dali::DaliException e) {
19508       {
19509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19510       };
19511     } catch (...) {
19512       {
19513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19514       };
19515     }
19516   }
19517
19518   jresult = (void *)result;
19519   return jresult;
19520 }
19521
19522
19523 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19524   unsigned long jresult ;
19525   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19526   std::size_t result;
19527
19528   arg1 = (Dali::PropertyCondition *)jarg1;
19529   {
19530     try {
19531       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19532     } catch (std::out_of_range& e) {
19533       {
19534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19535       };
19536     } catch (std::exception& e) {
19537       {
19538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19539       };
19540     } catch (...) {
19541       {
19542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19543       };
19544     }
19545   }
19546   jresult = (unsigned long)result;
19547   return jresult;
19548 }
19549
19550
19551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19552   float jresult ;
19553   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19554   std::size_t arg2 ;
19555   float result;
19556
19557   arg1 = (Dali::PropertyCondition *)jarg1;
19558   arg2 = (std::size_t)jarg2;
19559   {
19560     try {
19561       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19562     } catch (std::out_of_range& e) {
19563       {
19564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19565       };
19566     } catch (std::exception& e) {
19567       {
19568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19569       };
19570     } catch (...) {
19571       {
19572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19573       };
19574     }
19575   }
19576   jresult = result;
19577   return jresult;
19578 }
19579
19580
19581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19582   void * jresult ;
19583   float arg1 ;
19584   Dali::PropertyCondition result;
19585
19586   arg1 = (float)jarg1;
19587   {
19588     try {
19589       result = Dali::LessThanCondition(arg1);
19590     } catch (std::out_of_range& e) {
19591       {
19592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19593       };
19594     } catch (std::exception& e) {
19595       {
19596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19597       };
19598     } catch (Dali::DaliException e) {
19599       {
19600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19601       };
19602     } catch (...) {
19603       {
19604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19605       };
19606     }
19607   }
19608
19609   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19610   return jresult;
19611 }
19612
19613
19614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19615   void * jresult ;
19616   float arg1 ;
19617   Dali::PropertyCondition result;
19618
19619   arg1 = (float)jarg1;
19620   {
19621     try {
19622       result = Dali::GreaterThanCondition(arg1);
19623     } catch (std::out_of_range& e) {
19624       {
19625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19626       };
19627     } catch (std::exception& e) {
19628       {
19629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19630       };
19631     } catch (Dali::DaliException e) {
19632       {
19633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19634       };
19635     } catch (...) {
19636       {
19637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19638       };
19639     }
19640   }
19641
19642   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19643   return jresult;
19644 }
19645
19646
19647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19648   void * jresult ;
19649   float arg1 ;
19650   float arg2 ;
19651   Dali::PropertyCondition result;
19652
19653   arg1 = (float)jarg1;
19654   arg2 = (float)jarg2;
19655   {
19656     try {
19657       result = Dali::InsideCondition(arg1,arg2);
19658     } catch (std::out_of_range& e) {
19659       {
19660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19661       };
19662     } catch (std::exception& e) {
19663       {
19664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19665       };
19666     } catch (Dali::DaliException e) {
19667       {
19668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19669       };
19670     } catch (...) {
19671       {
19672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19673       };
19674     }
19675   }
19676
19677   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19678   return jresult;
19679 }
19680
19681
19682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19683   void * jresult ;
19684   float arg1 ;
19685   float arg2 ;
19686   Dali::PropertyCondition result;
19687
19688   arg1 = (float)jarg1;
19689   arg2 = (float)jarg2;
19690   {
19691     try {
19692       result = Dali::OutsideCondition(arg1,arg2);
19693     } catch (std::out_of_range& e) {
19694       {
19695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19696       };
19697     } catch (std::exception& e) {
19698       {
19699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19700       };
19701     } catch (Dali::DaliException e) {
19702       {
19703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19704       };
19705     } catch (...) {
19706       {
19707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19708       };
19709     }
19710   }
19711
19712   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19713   return jresult;
19714 }
19715
19716
19717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19718   void * jresult ;
19719   float arg1 ;
19720   float arg2 ;
19721   Dali::PropertyCondition result;
19722
19723   arg1 = (float)jarg1;
19724   arg2 = (float)jarg2;
19725   {
19726     try {
19727       result = Dali::StepCondition(arg1,arg2);
19728     } catch (std::out_of_range& e) {
19729       {
19730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19731       };
19732     } catch (std::exception& e) {
19733       {
19734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19735       };
19736     } catch (Dali::DaliException e) {
19737       {
19738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19739       };
19740     } catch (...) {
19741       {
19742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19743       };
19744     }
19745   }
19746
19747   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19748   return jresult;
19749 }
19750
19751
19752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19753   void * jresult ;
19754   float arg1 ;
19755   Dali::PropertyCondition result;
19756
19757   arg1 = (float)jarg1;
19758   {
19759     try {
19760       result = Dali::StepCondition(arg1);
19761     } catch (std::out_of_range& e) {
19762       {
19763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19764       };
19765     } catch (std::exception& e) {
19766       {
19767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19768       };
19769     } catch (Dali::DaliException e) {
19770       {
19771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19772       };
19773     } catch (...) {
19774       {
19775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19776       };
19777     }
19778   }
19779
19780   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19781   return jresult;
19782 }
19783
19784
19785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19786   void * jresult ;
19787   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19788   Dali::PropertyCondition result;
19789
19790   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19791   if (!arg1) {
19792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19793     return 0;
19794   }
19795   {
19796     try {
19797       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19798     } catch (std::out_of_range& e) {
19799       {
19800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19801       };
19802     } catch (std::exception& e) {
19803       {
19804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19805       };
19806     } catch (Dali::DaliException e) {
19807       {
19808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19809       };
19810     } catch (...) {
19811       {
19812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19813       };
19814     }
19815   }
19816
19817   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19818   return jresult;
19819 }
19820
19821
19822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19823   void * jresult ;
19824   Dali::PropertyNotification *result = 0 ;
19825
19826   {
19827     try {
19828       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19829     } catch (std::out_of_range& e) {
19830       {
19831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19832       };
19833     } catch (std::exception& e) {
19834       {
19835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19836       };
19837     } catch (Dali::DaliException e) {
19838       {
19839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19840       };
19841     } catch (...) {
19842       {
19843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19844       };
19845     }
19846   }
19847
19848   jresult = (void *)result;
19849   return jresult;
19850 }
19851
19852
19853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19854   void * jresult ;
19855   Dali::BaseHandle arg1 ;
19856   Dali::BaseHandle *argp1 ;
19857   Dali::PropertyNotification result;
19858
19859   argp1 = (Dali::BaseHandle *)jarg1;
19860   if (!argp1) {
19861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19862     return 0;
19863   }
19864   arg1 = *argp1;
19865   {
19866     try {
19867       result = Dali::PropertyNotification::DownCast(arg1);
19868     } catch (std::out_of_range& e) {
19869       {
19870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19871       };
19872     } catch (std::exception& e) {
19873       {
19874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19875       };
19876     } catch (Dali::DaliException e) {
19877       {
19878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19879       };
19880     } catch (...) {
19881       {
19882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19883       };
19884     }
19885   }
19886
19887   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19888   return jresult;
19889 }
19890
19891
19892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19893   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19894
19895   arg1 = (Dali::PropertyNotification *)jarg1;
19896   {
19897     try {
19898       delete arg1;
19899     } catch (std::out_of_range& e) {
19900       {
19901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19902       };
19903     } catch (std::exception& e) {
19904       {
19905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19906       };
19907     } catch (Dali::DaliException e) {
19908       {
19909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19910       };
19911     } catch (...) {
19912       {
19913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19914       };
19915     }
19916   }
19917
19918 }
19919
19920
19921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19922   void * jresult ;
19923   Dali::PropertyNotification *arg1 = 0 ;
19924   Dali::PropertyNotification *result = 0 ;
19925
19926   arg1 = (Dali::PropertyNotification *)jarg1;
19927   if (!arg1) {
19928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19929     return 0;
19930   }
19931   {
19932     try {
19933       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19934     } catch (std::out_of_range& e) {
19935       {
19936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19937       };
19938     } catch (std::exception& e) {
19939       {
19940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19941       };
19942     } catch (Dali::DaliException e) {
19943       {
19944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19945       };
19946     } catch (...) {
19947       {
19948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19949       };
19950     }
19951   }
19952
19953   jresult = (void *)result;
19954   return jresult;
19955 }
19956
19957
19958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19959   void * jresult ;
19960   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19961   Dali::PropertyNotification *arg2 = 0 ;
19962   Dali::PropertyNotification *result = 0 ;
19963
19964   arg1 = (Dali::PropertyNotification *)jarg1;
19965   arg2 = (Dali::PropertyNotification *)jarg2;
19966   if (!arg2) {
19967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19968     return 0;
19969   }
19970   {
19971     try {
19972       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19973     } catch (std::out_of_range& e) {
19974       {
19975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19976       };
19977     } catch (std::exception& e) {
19978       {
19979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19980       };
19981     } catch (Dali::DaliException e) {
19982       {
19983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19984       };
19985     } catch (...) {
19986       {
19987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19988       };
19989     }
19990   }
19991
19992   jresult = (void *)result;
19993   return jresult;
19994 }
19995
19996
19997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19998   void * jresult ;
19999   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20000   Dali::PropertyCondition result;
20001
20002   arg1 = (Dali::PropertyNotification *)jarg1;
20003   {
20004     try {
20005       result = (arg1)->GetCondition();
20006     } catch (std::out_of_range& e) {
20007       {
20008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20009       };
20010     } catch (std::exception& e) {
20011       {
20012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20013       };
20014     } catch (Dali::DaliException e) {
20015       {
20016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20017       };
20018     } catch (...) {
20019       {
20020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20021       };
20022     }
20023   }
20024
20025   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20026   return jresult;
20027 }
20028
20029
20030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20031   void * jresult ;
20032   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20033   Dali::Handle result;
20034
20035   arg1 = (Dali::PropertyNotification *)jarg1;
20036   {
20037     try {
20038       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20039     } catch (std::out_of_range& e) {
20040       {
20041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20042       };
20043     } catch (std::exception& e) {
20044       {
20045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20046       };
20047     } catch (Dali::DaliException e) {
20048       {
20049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20050       };
20051     } catch (...) {
20052       {
20053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20054       };
20055     }
20056   }
20057
20058   jresult = new Dali::Handle((const Dali::Handle &)result);
20059   return jresult;
20060 }
20061
20062
20063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20064   int jresult ;
20065   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20066   Dali::Property::Index result;
20067
20068   arg1 = (Dali::PropertyNotification *)jarg1;
20069   {
20070     try {
20071       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20072     } catch (std::out_of_range& e) {
20073       {
20074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20075       };
20076     } catch (std::exception& e) {
20077       {
20078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20079       };
20080     } catch (Dali::DaliException e) {
20081       {
20082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20083       };
20084     } catch (...) {
20085       {
20086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20087       };
20088     }
20089   }
20090
20091   jresult = result;
20092   return jresult;
20093 }
20094
20095
20096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20097   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20098   Dali::PropertyNotification::NotifyMode arg2 ;
20099
20100   arg1 = (Dali::PropertyNotification *)jarg1;
20101   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20102   {
20103     try {
20104       (arg1)->SetNotifyMode(arg2);
20105     } catch (std::out_of_range& e) {
20106       {
20107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20108       };
20109     } catch (std::exception& e) {
20110       {
20111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20112       };
20113     } catch (Dali::DaliException e) {
20114       {
20115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20116       };
20117     } catch (...) {
20118       {
20119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20120       };
20121     }
20122   }
20123
20124 }
20125
20126
20127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20128   int jresult ;
20129   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20130   Dali::PropertyNotification::NotifyMode result;
20131
20132   arg1 = (Dali::PropertyNotification *)jarg1;
20133   {
20134     try {
20135       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20136     } catch (std::out_of_range& e) {
20137       {
20138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20139       };
20140     } catch (std::exception& e) {
20141       {
20142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20143       };
20144     } catch (Dali::DaliException e) {
20145       {
20146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20147       };
20148     } catch (...) {
20149       {
20150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20151       };
20152     }
20153   }
20154
20155   jresult = (int)result;
20156   return jresult;
20157 }
20158
20159
20160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20161   unsigned int jresult ;
20162   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20163   bool result;
20164
20165   arg1 = (Dali::PropertyNotification *)jarg1;
20166   {
20167     try {
20168       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20169     } catch (std::out_of_range& e) {
20170       {
20171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20172       };
20173     } catch (std::exception& e) {
20174       {
20175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20176       };
20177     } catch (Dali::DaliException e) {
20178       {
20179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20180       };
20181     } catch (...) {
20182       {
20183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20184       };
20185     }
20186   }
20187
20188   jresult = result;
20189   return jresult;
20190 }
20191
20192
20193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20194   void * jresult ;
20195   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20196   Dali::PropertyNotifySignalType *result = 0 ;
20197
20198   arg1 = (Dali::PropertyNotification *)jarg1;
20199   {
20200     try {
20201       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20202     } catch (std::out_of_range& e) {
20203       {
20204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20205       };
20206     } catch (std::exception& e) {
20207       {
20208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20209       };
20210     } catch (Dali::DaliException e) {
20211       {
20212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20213       };
20214     } catch (...) {
20215       {
20216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20217       };
20218     }
20219   }
20220
20221   jresult = (void *)result;
20222   return jresult;
20223 }
20224
20225
20226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20227   void * jresult ;
20228   Dali::Handle *result = 0 ;
20229
20230   {
20231     try {
20232       result = (Dali::Handle *)new Dali::Handle();
20233     } catch (std::out_of_range& e) {
20234       {
20235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20236       };
20237     } catch (std::exception& e) {
20238       {
20239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20240       };
20241     } catch (Dali::DaliException e) {
20242       {
20243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20244       };
20245     } catch (...) {
20246       {
20247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20248       };
20249     }
20250   }
20251
20252   jresult = (void *)result;
20253   return jresult;
20254 }
20255
20256
20257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20258   void * jresult ;
20259   Dali::Handle result;
20260
20261   {
20262     try {
20263       result = Dali::Handle::New();
20264     } catch (std::out_of_range& e) {
20265       {
20266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20267       };
20268     } catch (std::exception& e) {
20269       {
20270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20271       };
20272     } catch (Dali::DaliException e) {
20273       {
20274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20275       };
20276     } catch (...) {
20277       {
20278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20279       };
20280     }
20281   }
20282
20283   jresult = new Dali::Handle((const Dali::Handle &)result);
20284   return jresult;
20285 }
20286
20287
20288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20289   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20290
20291   arg1 = (Dali::Handle *)jarg1;
20292   {
20293     try {
20294       delete arg1;
20295     } catch (std::out_of_range& e) {
20296       {
20297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20298       };
20299     } catch (std::exception& e) {
20300       {
20301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20302       };
20303     } catch (Dali::DaliException e) {
20304       {
20305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20306       };
20307     } catch (...) {
20308       {
20309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20310       };
20311     }
20312   }
20313
20314 }
20315
20316
20317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20318   void * jresult ;
20319   Dali::Handle *arg1 = 0 ;
20320   Dali::Handle *result = 0 ;
20321
20322   arg1 = (Dali::Handle *)jarg1;
20323   if (!arg1) {
20324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20325     return 0;
20326   }
20327   {
20328     try {
20329       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20330     } catch (std::out_of_range& e) {
20331       {
20332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20333       };
20334     } catch (std::exception& e) {
20335       {
20336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20337       };
20338     } catch (Dali::DaliException e) {
20339       {
20340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20341       };
20342     } catch (...) {
20343       {
20344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20345       };
20346     }
20347   }
20348
20349   jresult = (void *)result;
20350   return jresult;
20351 }
20352
20353
20354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20355   void * jresult ;
20356   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20357   Dali::Handle *arg2 = 0 ;
20358   Dali::Handle *result = 0 ;
20359
20360   arg1 = (Dali::Handle *)jarg1;
20361   arg2 = (Dali::Handle *)jarg2;
20362   if (!arg2) {
20363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20364     return 0;
20365   }
20366   {
20367     try {
20368       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20369     } catch (std::out_of_range& e) {
20370       {
20371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20372       };
20373     } catch (std::exception& e) {
20374       {
20375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20376       };
20377     } catch (Dali::DaliException e) {
20378       {
20379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20380       };
20381     } catch (...) {
20382       {
20383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20384       };
20385     }
20386   }
20387
20388   jresult = (void *)result;
20389   return jresult;
20390 }
20391
20392
20393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20394   void * jresult ;
20395   Dali::BaseHandle arg1 ;
20396   Dali::BaseHandle *argp1 ;
20397   Dali::Handle result;
20398
20399   argp1 = (Dali::BaseHandle *)jarg1;
20400   if (!argp1) {
20401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20402     return 0;
20403   }
20404   arg1 = *argp1;
20405   {
20406     try {
20407       result = Dali::Handle::DownCast(arg1);
20408     } catch (std::out_of_range& e) {
20409       {
20410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20411       };
20412     } catch (std::exception& e) {
20413       {
20414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20415       };
20416     } catch (Dali::DaliException e) {
20417       {
20418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20419       };
20420     } catch (...) {
20421       {
20422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20423       };
20424     }
20425   }
20426
20427   jresult = new Dali::Handle((const Dali::Handle &)result);
20428   return jresult;
20429 }
20430
20431
20432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20433   unsigned int jresult ;
20434   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20435   Dali::Handle::Capability arg2 ;
20436   bool result;
20437
20438   arg1 = (Dali::Handle *)jarg1;
20439   arg2 = (Dali::Handle::Capability)jarg2;
20440   {
20441     try {
20442       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20443     } catch (std::out_of_range& e) {
20444       {
20445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20446       };
20447     } catch (std::exception& e) {
20448       {
20449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20450       };
20451     } catch (Dali::DaliException e) {
20452       {
20453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20454       };
20455     } catch (...) {
20456       {
20457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20458       };
20459     }
20460   }
20461
20462   jresult = result;
20463   return jresult;
20464 }
20465
20466
20467 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20468   unsigned int jresult ;
20469   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20470   unsigned int result;
20471
20472   arg1 = (Dali::Handle *)jarg1;
20473   {
20474     try {
20475       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20476     } catch (std::out_of_range& e) {
20477       {
20478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20479       };
20480     } catch (std::exception& e) {
20481       {
20482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20483       };
20484     } catch (Dali::DaliException e) {
20485       {
20486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20487       };
20488     } catch (...) {
20489       {
20490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20491       };
20492     }
20493   }
20494
20495   jresult = result;
20496   return jresult;
20497 }
20498
20499
20500 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20501   char * jresult ;
20502   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20503   Dali::Property::Index arg2 ;
20504   std::string result;
20505
20506   arg1 = (Dali::Handle *)jarg1;
20507   arg2 = (Dali::Property::Index)jarg2;
20508   {
20509     try {
20510       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20511     } catch (std::out_of_range& e) {
20512       {
20513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20514       };
20515     } catch (std::exception& e) {
20516       {
20517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20518       };
20519     } catch (Dali::DaliException e) {
20520       {
20521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20522       };
20523     } catch (...) {
20524       {
20525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20526       };
20527     }
20528   }
20529
20530   jresult = SWIG_csharp_string_callback((&result)->c_str());
20531   return jresult;
20532 }
20533
20534
20535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20536   int jresult ;
20537   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20538   std::string *arg2 = 0 ;
20539   Dali::Property::Index result;
20540
20541   arg1 = (Dali::Handle *)jarg1;
20542   if (!jarg2) {
20543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20544     return 0;
20545   }
20546   std::string arg2_str(jarg2);
20547   arg2 = &arg2_str;
20548   {
20549     try {
20550       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20551     } catch (std::out_of_range& e) {
20552       {
20553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20554       };
20555     } catch (std::exception& e) {
20556       {
20557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20558       };
20559     } catch (Dali::DaliException e) {
20560       {
20561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20562       };
20563     } catch (...) {
20564       {
20565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20566       };
20567     }
20568   }
20569
20570   jresult = result;
20571
20572   //argout typemap for const std::string&
20573
20574   return jresult;
20575 }
20576
20577
20578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20579   unsigned int jresult ;
20580   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20581   Dali::Property::Index arg2 ;
20582   bool result;
20583
20584   arg1 = (Dali::Handle *)jarg1;
20585   arg2 = (Dali::Property::Index)jarg2;
20586   {
20587     try {
20588       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20589     } catch (std::out_of_range& e) {
20590       {
20591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20592       };
20593     } catch (std::exception& e) {
20594       {
20595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20596       };
20597     } catch (Dali::DaliException e) {
20598       {
20599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20600       };
20601     } catch (...) {
20602       {
20603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20604       };
20605     }
20606   }
20607
20608   jresult = result;
20609   return jresult;
20610 }
20611
20612
20613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20614   unsigned int jresult ;
20615   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20616   Dali::Property::Index arg2 ;
20617   bool result;
20618
20619   arg1 = (Dali::Handle *)jarg1;
20620   arg2 = (Dali::Property::Index)jarg2;
20621   {
20622     try {
20623       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20624     } catch (std::out_of_range& e) {
20625       {
20626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20627       };
20628     } catch (std::exception& e) {
20629       {
20630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20631       };
20632     } catch (Dali::DaliException e) {
20633       {
20634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20635       };
20636     } catch (...) {
20637       {
20638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20639       };
20640     }
20641   }
20642
20643   jresult = result;
20644   return jresult;
20645 }
20646
20647
20648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20649   unsigned int jresult ;
20650   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20651   Dali::Property::Index arg2 ;
20652   bool result;
20653
20654   arg1 = (Dali::Handle *)jarg1;
20655   arg2 = (Dali::Property::Index)jarg2;
20656   {
20657     try {
20658       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20659     } catch (std::out_of_range& e) {
20660       {
20661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20662       };
20663     } catch (std::exception& e) {
20664       {
20665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20666       };
20667     } catch (Dali::DaliException e) {
20668       {
20669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20670       };
20671     } catch (...) {
20672       {
20673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20674       };
20675     }
20676   }
20677
20678   jresult = result;
20679   return jresult;
20680 }
20681
20682
20683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20684   int jresult ;
20685   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20686   Dali::Property::Index arg2 ;
20687   Dali::Property::Type result;
20688
20689   arg1 = (Dali::Handle *)jarg1;
20690   arg2 = (Dali::Property::Index)jarg2;
20691   {
20692     try {
20693       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20694     } catch (std::out_of_range& e) {
20695       {
20696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20697       };
20698     } catch (std::exception& e) {
20699       {
20700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20701       };
20702     } catch (Dali::DaliException e) {
20703       {
20704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20705       };
20706     } catch (...) {
20707       {
20708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20709       };
20710     }
20711   }
20712
20713   jresult = (int)result;
20714   return jresult;
20715 }
20716
20717
20718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20719   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20720   Dali::Property::Index arg2 ;
20721   Dali::Property::Value *arg3 = 0 ;
20722
20723   arg1 = (Dali::Handle *)jarg1;
20724   arg2 = (Dali::Property::Index)jarg2;
20725   arg3 = (Dali::Property::Value *)jarg3;
20726   if (!arg3) {
20727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20728     return ;
20729   }
20730   {
20731     try {
20732       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20733     } catch (std::out_of_range& e) {
20734       {
20735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20736       };
20737     } catch (std::exception& e) {
20738       {
20739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20740       };
20741     } catch (Dali::DaliException e) {
20742       {
20743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20744       };
20745     } catch (...) {
20746       {
20747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20748       };
20749     }
20750   }
20751
20752 }
20753
20754
20755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20756   int jresult ;
20757   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20758   std::string *arg2 = 0 ;
20759   Dali::Property::Value *arg3 = 0 ;
20760   Dali::Property::Index result;
20761
20762   arg1 = (Dali::Handle *)jarg1;
20763   if (!jarg2) {
20764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20765     return 0;
20766   }
20767   std::string arg2_str(jarg2);
20768   arg2 = &arg2_str;
20769   arg3 = (Dali::Property::Value *)jarg3;
20770   if (!arg3) {
20771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20772     return 0;
20773   }
20774   {
20775     try {
20776       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20777     } catch (std::out_of_range& e) {
20778       {
20779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20780       };
20781     } catch (std::exception& e) {
20782       {
20783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20784       };
20785     } catch (Dali::DaliException e) {
20786       {
20787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20788       };
20789     } catch (...) {
20790       {
20791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20792       };
20793     }
20794   }
20795
20796   jresult = result;
20797
20798   //argout typemap for const std::string&
20799
20800   return jresult;
20801 }
20802
20803
20804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20805   int jresult ;
20806   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20807   std::string *arg2 = 0 ;
20808   Dali::Property::Value *arg3 = 0 ;
20809   Dali::Property::AccessMode arg4 ;
20810   Dali::Property::Index result;
20811
20812   arg1 = (Dali::Handle *)jarg1;
20813   if (!jarg2) {
20814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20815     return 0;
20816   }
20817   std::string arg2_str(jarg2);
20818   arg2 = &arg2_str;
20819   arg3 = (Dali::Property::Value *)jarg3;
20820   if (!arg3) {
20821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20822     return 0;
20823   }
20824   arg4 = (Dali::Property::AccessMode)jarg4;
20825   {
20826     try {
20827       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20828     } catch (std::out_of_range& e) {
20829       {
20830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20831       };
20832     } catch (std::exception& e) {
20833       {
20834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20835       };
20836     } catch (Dali::DaliException e) {
20837       {
20838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20839       };
20840     } catch (...) {
20841       {
20842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20843       };
20844     }
20845   }
20846
20847   jresult = result;
20848
20849   //argout typemap for const std::string&
20850
20851   return jresult;
20852 }
20853
20854
20855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20856   void * jresult ;
20857   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20858   Dali::Property::Index arg2 ;
20859   Dali::Property::Value result;
20860
20861   arg1 = (Dali::Handle *)jarg1;
20862   arg2 = (Dali::Property::Index)jarg2;
20863   {
20864     try {
20865       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20866     } catch (std::out_of_range& e) {
20867       {
20868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20869       };
20870     } catch (std::exception& e) {
20871       {
20872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20873       };
20874     } catch (Dali::DaliException e) {
20875       {
20876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20877       };
20878     } catch (...) {
20879       {
20880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20881       };
20882     }
20883   }
20884
20885   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20886   return jresult;
20887 }
20888
20889
20890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20891   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20892   Dali::Property::IndexContainer *arg2 = 0 ;
20893
20894   arg1 = (Dali::Handle *)jarg1;
20895   arg2 = (Dali::Property::IndexContainer *)jarg2;
20896   if (!arg2) {
20897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20898     return ;
20899   }
20900   {
20901     try {
20902       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20903     } catch (std::out_of_range& e) {
20904       {
20905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20906       };
20907     } catch (std::exception& e) {
20908       {
20909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20910       };
20911     } catch (Dali::DaliException e) {
20912       {
20913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20914       };
20915     } catch (...) {
20916       {
20917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20918       };
20919     }
20920   }
20921
20922 }
20923
20924
20925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20926   void * jresult ;
20927   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20928   Dali::Property::Index arg2 ;
20929   Dali::PropertyCondition *arg3 = 0 ;
20930   Dali::PropertyNotification result;
20931
20932   arg1 = (Dali::Handle *)jarg1;
20933   arg2 = (Dali::Property::Index)jarg2;
20934   arg3 = (Dali::PropertyCondition *)jarg3;
20935   if (!arg3) {
20936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20937     return 0;
20938   }
20939   {
20940     try {
20941       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20942     } catch (std::out_of_range& e) {
20943       {
20944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20945       };
20946     } catch (std::exception& e) {
20947       {
20948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20949       };
20950     } catch (Dali::DaliException e) {
20951       {
20952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20953       };
20954     } catch (...) {
20955       {
20956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20957       };
20958     }
20959   }
20960
20961   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20962   return jresult;
20963 }
20964
20965
20966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20967   void * jresult ;
20968   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20969   Dali::Property::Index arg2 ;
20970   int arg3 ;
20971   Dali::PropertyCondition *arg4 = 0 ;
20972   Dali::PropertyNotification result;
20973
20974   arg1 = (Dali::Handle *)jarg1;
20975   arg2 = (Dali::Property::Index)jarg2;
20976   arg3 = (int)jarg3;
20977   arg4 = (Dali::PropertyCondition *)jarg4;
20978   if (!arg4) {
20979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20980     return 0;
20981   }
20982   {
20983     try {
20984       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20985     } catch (std::out_of_range& e) {
20986       {
20987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20988       };
20989     } catch (std::exception& e) {
20990       {
20991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20992       };
20993     } catch (Dali::DaliException e) {
20994       {
20995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20996       };
20997     } catch (...) {
20998       {
20999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21000       };
21001     }
21002   }
21003
21004   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21005   return jresult;
21006 }
21007
21008
21009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21010   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21011   Dali::PropertyNotification arg2 ;
21012   Dali::PropertyNotification *argp2 ;
21013
21014   arg1 = (Dali::Handle *)jarg1;
21015   argp2 = (Dali::PropertyNotification *)jarg2;
21016   if (!argp2) {
21017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21018     return ;
21019   }
21020   arg2 = *argp2;
21021   {
21022     try {
21023       (arg1)->RemovePropertyNotification(arg2);
21024     } catch (std::out_of_range& e) {
21025       {
21026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21027       };
21028     } catch (std::exception& e) {
21029       {
21030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21031       };
21032     } catch (Dali::DaliException e) {
21033       {
21034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21035       };
21036     } catch (...) {
21037       {
21038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21039       };
21040     }
21041   }
21042
21043 }
21044
21045
21046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21047   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21048
21049   arg1 = (Dali::Handle *)jarg1;
21050   {
21051     try {
21052       (arg1)->RemovePropertyNotifications();
21053     } catch (std::out_of_range& e) {
21054       {
21055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21056       };
21057     } catch (std::exception& e) {
21058       {
21059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21060       };
21061     } catch (Dali::DaliException e) {
21062       {
21063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21064       };
21065     } catch (...) {
21066       {
21067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21068       };
21069     }
21070   }
21071
21072 }
21073
21074
21075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21076   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21077
21078   arg1 = (Dali::Handle *)jarg1;
21079   {
21080     try {
21081       (arg1)->RemoveConstraints();
21082     } catch (std::out_of_range& e) {
21083       {
21084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21085       };
21086     } catch (std::exception& e) {
21087       {
21088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21089       };
21090     } catch (Dali::DaliException e) {
21091       {
21092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21093       };
21094     } catch (...) {
21095       {
21096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21097       };
21098     }
21099   }
21100
21101 }
21102
21103
21104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21105   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21106   unsigned int arg2 ;
21107
21108   arg1 = (Dali::Handle *)jarg1;
21109   arg2 = (unsigned int)jarg2;
21110   {
21111     try {
21112       (arg1)->RemoveConstraints(arg2);
21113     } catch (std::out_of_range& e) {
21114       {
21115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21116       };
21117     } catch (std::exception& e) {
21118       {
21119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21120       };
21121     } catch (Dali::DaliException e) {
21122       {
21123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21124       };
21125     } catch (...) {
21126       {
21127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21128       };
21129     }
21130   }
21131
21132 }
21133
21134
21135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21136   int jresult ;
21137   Dali::Property::Index result;
21138
21139   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21140   jresult = result;
21141   return jresult;
21142 }
21143
21144
21145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21146   void * jresult ;
21147   Dali::Handle result;
21148
21149   {
21150     try {
21151       result = Dali::WeightObject::New();
21152     } catch (std::out_of_range& e) {
21153       {
21154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21155       };
21156     } catch (std::exception& e) {
21157       {
21158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21159       };
21160     } catch (Dali::DaliException e) {
21161       {
21162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21163       };
21164     } catch (...) {
21165       {
21166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21167       };
21168     }
21169   }
21170
21171   jresult = new Dali::Handle((const Dali::Handle &)result);
21172   return jresult;
21173 }
21174
21175
21176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21177   void * jresult ;
21178   Dali::TypeInfo *result = 0 ;
21179
21180   {
21181     try {
21182       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21183     } catch (std::out_of_range& e) {
21184       {
21185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21186       };
21187     } catch (std::exception& e) {
21188       {
21189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21190       };
21191     } catch (Dali::DaliException e) {
21192       {
21193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21194       };
21195     } catch (...) {
21196       {
21197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21198       };
21199     }
21200   }
21201
21202   jresult = (void *)result;
21203   return jresult;
21204 }
21205
21206
21207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21208   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21209
21210   arg1 = (Dali::TypeInfo *)jarg1;
21211   {
21212     try {
21213       delete arg1;
21214     } catch (std::out_of_range& e) {
21215       {
21216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21217       };
21218     } catch (std::exception& e) {
21219       {
21220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21221       };
21222     } catch (Dali::DaliException e) {
21223       {
21224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21225       };
21226     } catch (...) {
21227       {
21228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21229       };
21230     }
21231   }
21232
21233 }
21234
21235
21236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21237   void * jresult ;
21238   Dali::TypeInfo *arg1 = 0 ;
21239   Dali::TypeInfo *result = 0 ;
21240
21241   arg1 = (Dali::TypeInfo *)jarg1;
21242   if (!arg1) {
21243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21244     return 0;
21245   }
21246   {
21247     try {
21248       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21249     } catch (std::out_of_range& e) {
21250       {
21251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21252       };
21253     } catch (std::exception& e) {
21254       {
21255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21256       };
21257     } catch (Dali::DaliException e) {
21258       {
21259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21260       };
21261     } catch (...) {
21262       {
21263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21264       };
21265     }
21266   }
21267
21268   jresult = (void *)result;
21269   return jresult;
21270 }
21271
21272
21273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21274   void * jresult ;
21275   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21276   Dali::TypeInfo *arg2 = 0 ;
21277   Dali::TypeInfo *result = 0 ;
21278
21279   arg1 = (Dali::TypeInfo *)jarg1;
21280   arg2 = (Dali::TypeInfo *)jarg2;
21281   if (!arg2) {
21282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21283     return 0;
21284   }
21285   {
21286     try {
21287       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21288     } catch (std::out_of_range& e) {
21289       {
21290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21291       };
21292     } catch (std::exception& e) {
21293       {
21294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21295       };
21296     } catch (Dali::DaliException e) {
21297       {
21298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21299       };
21300     } catch (...) {
21301       {
21302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21303       };
21304     }
21305   }
21306
21307   jresult = (void *)result;
21308   return jresult;
21309 }
21310
21311
21312 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21313   char * jresult ;
21314   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21315   std::string *result = 0 ;
21316
21317   arg1 = (Dali::TypeInfo *)jarg1;
21318   {
21319     try {
21320       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21321     } catch (std::out_of_range& e) {
21322       {
21323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21324       };
21325     } catch (std::exception& e) {
21326       {
21327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21328       };
21329     } catch (Dali::DaliException e) {
21330       {
21331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21332       };
21333     } catch (...) {
21334       {
21335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21336       };
21337     }
21338   }
21339
21340   jresult = SWIG_csharp_string_callback(result->c_str());
21341   return jresult;
21342 }
21343
21344
21345 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21346   char * jresult ;
21347   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21348   std::string *result = 0 ;
21349
21350   arg1 = (Dali::TypeInfo *)jarg1;
21351   {
21352     try {
21353       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21354     } catch (std::out_of_range& e) {
21355       {
21356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21357       };
21358     } catch (std::exception& e) {
21359       {
21360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21361       };
21362     } catch (Dali::DaliException e) {
21363       {
21364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21365       };
21366     } catch (...) {
21367       {
21368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21369       };
21370     }
21371   }
21372
21373   jresult = SWIG_csharp_string_callback(result->c_str());
21374   return jresult;
21375 }
21376
21377
21378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21379   void * jresult ;
21380   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21381   Dali::BaseHandle result;
21382
21383   arg1 = (Dali::TypeInfo *)jarg1;
21384   {
21385     try {
21386       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21387     } catch (std::out_of_range& e) {
21388       {
21389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21390       };
21391     } catch (std::exception& e) {
21392       {
21393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21394       };
21395     } catch (Dali::DaliException e) {
21396       {
21397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21398       };
21399     } catch (...) {
21400       {
21401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21402       };
21403     }
21404   }
21405
21406   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21407   return jresult;
21408 }
21409
21410
21411 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21412   unsigned long jresult ;
21413   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21414   size_t result;
21415
21416   arg1 = (Dali::TypeInfo *)jarg1;
21417   {
21418     try {
21419       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21420     } catch (std::out_of_range& e) {
21421       {
21422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21423       };
21424     } catch (std::exception& e) {
21425       {
21426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21427       };
21428     } catch (Dali::DaliException e) {
21429       {
21430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21431       };
21432     } catch (...) {
21433       {
21434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21435       };
21436     }
21437   }
21438
21439   jresult = (unsigned long)result;
21440   return jresult;
21441 }
21442
21443
21444 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21445   char * jresult ;
21446   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21447   size_t arg2 ;
21448   std::string result;
21449
21450   arg1 = (Dali::TypeInfo *)jarg1;
21451   arg2 = (size_t)jarg2;
21452   {
21453     try {
21454       result = (arg1)->GetActionName(arg2);
21455     } catch (std::out_of_range& e) {
21456       {
21457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21458       };
21459     } catch (std::exception& e) {
21460       {
21461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21462       };
21463     } catch (Dali::DaliException e) {
21464       {
21465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21466       };
21467     } catch (...) {
21468       {
21469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21470       };
21471     }
21472   }
21473
21474   jresult = SWIG_csharp_string_callback((&result)->c_str());
21475   return jresult;
21476 }
21477
21478
21479 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21480   unsigned long jresult ;
21481   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21482   size_t result;
21483
21484   arg1 = (Dali::TypeInfo *)jarg1;
21485   {
21486     try {
21487       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21488     } catch (std::out_of_range& e) {
21489       {
21490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21491       };
21492     } catch (std::exception& e) {
21493       {
21494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21495       };
21496     } catch (Dali::DaliException e) {
21497       {
21498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21499       };
21500     } catch (...) {
21501       {
21502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21503       };
21504     }
21505   }
21506
21507   jresult = (unsigned long)result;
21508   return jresult;
21509 }
21510
21511
21512 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21513   char * jresult ;
21514   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21515   size_t arg2 ;
21516   std::string result;
21517
21518   arg1 = (Dali::TypeInfo *)jarg1;
21519   arg2 = (size_t)jarg2;
21520   {
21521     try {
21522       result = (arg1)->GetSignalName(arg2);
21523     } catch (std::out_of_range& e) {
21524       {
21525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21526       };
21527     } catch (std::exception& e) {
21528       {
21529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21530       };
21531     } catch (Dali::DaliException e) {
21532       {
21533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21534       };
21535     } catch (...) {
21536       {
21537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21538       };
21539     }
21540   }
21541
21542   jresult = SWIG_csharp_string_callback((&result)->c_str());
21543   return jresult;
21544 }
21545
21546
21547 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21548   unsigned long jresult ;
21549   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21550   size_t result;
21551
21552   arg1 = (Dali::TypeInfo *)jarg1;
21553   {
21554     try {
21555       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21556     } catch (std::out_of_range& e) {
21557       {
21558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21559       };
21560     } catch (std::exception& e) {
21561       {
21562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21563       };
21564     } catch (Dali::DaliException e) {
21565       {
21566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21567       };
21568     } catch (...) {
21569       {
21570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21571       };
21572     }
21573   }
21574
21575   jresult = (unsigned long)result;
21576   return jresult;
21577 }
21578
21579
21580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21581   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21582   Dali::Property::IndexContainer *arg2 = 0 ;
21583
21584   arg1 = (Dali::TypeInfo *)jarg1;
21585   arg2 = (Dali::Property::IndexContainer *)jarg2;
21586   if (!arg2) {
21587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21588     return ;
21589   }
21590   {
21591     try {
21592       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21593     } catch (std::out_of_range& e) {
21594       {
21595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21596       };
21597     } catch (std::exception& e) {
21598       {
21599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21600       };
21601     } catch (Dali::DaliException e) {
21602       {
21603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21604       };
21605     } catch (...) {
21606       {
21607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21608       };
21609     }
21610   }
21611
21612 }
21613
21614
21615 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21616   char * jresult ;
21617   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21618   Dali::Property::Index arg2 ;
21619   std::string *result = 0 ;
21620
21621   arg1 = (Dali::TypeInfo *)jarg1;
21622   arg2 = (Dali::Property::Index)jarg2;
21623   {
21624     try {
21625       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21626     } catch (std::out_of_range& e) {
21627       {
21628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21629       };
21630     } catch (std::exception& e) {
21631       {
21632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21633       };
21634     } catch (Dali::DaliException e) {
21635       {
21636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21637       };
21638     } catch (...) {
21639       {
21640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21641       };
21642     }
21643   }
21644
21645   jresult = SWIG_csharp_string_callback(result->c_str());
21646   return jresult;
21647 }
21648
21649
21650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21651   void * jresult ;
21652   Dali::TypeRegistry result;
21653
21654   {
21655     try {
21656       result = Dali::TypeRegistry::Get();
21657     } catch (std::out_of_range& e) {
21658       {
21659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21660       };
21661     } catch (std::exception& e) {
21662       {
21663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21664       };
21665     } catch (Dali::DaliException e) {
21666       {
21667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21668       };
21669     } catch (...) {
21670       {
21671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21672       };
21673     }
21674   }
21675
21676   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21677   return jresult;
21678 }
21679
21680
21681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21682   void * jresult ;
21683   Dali::TypeRegistry *result = 0 ;
21684
21685   {
21686     try {
21687       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21688     } catch (std::out_of_range& e) {
21689       {
21690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21691       };
21692     } catch (std::exception& e) {
21693       {
21694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21695       };
21696     } catch (Dali::DaliException e) {
21697       {
21698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21699       };
21700     } catch (...) {
21701       {
21702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21703       };
21704     }
21705   }
21706
21707   jresult = (void *)result;
21708   return jresult;
21709 }
21710
21711
21712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21713   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21714
21715   arg1 = (Dali::TypeRegistry *)jarg1;
21716   {
21717     try {
21718       delete arg1;
21719     } catch (std::out_of_range& e) {
21720       {
21721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21722       };
21723     } catch (std::exception& e) {
21724       {
21725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21726       };
21727     } catch (Dali::DaliException e) {
21728       {
21729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21730       };
21731     } catch (...) {
21732       {
21733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21734       };
21735     }
21736   }
21737
21738 }
21739
21740
21741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21742   void * jresult ;
21743   Dali::TypeRegistry *arg1 = 0 ;
21744   Dali::TypeRegistry *result = 0 ;
21745
21746   arg1 = (Dali::TypeRegistry *)jarg1;
21747   if (!arg1) {
21748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21749     return 0;
21750   }
21751   {
21752     try {
21753       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21754     } catch (std::out_of_range& e) {
21755       {
21756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21757       };
21758     } catch (std::exception& e) {
21759       {
21760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21761       };
21762     } catch (Dali::DaliException e) {
21763       {
21764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21765       };
21766     } catch (...) {
21767       {
21768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21769       };
21770     }
21771   }
21772
21773   jresult = (void *)result;
21774   return jresult;
21775 }
21776
21777
21778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21779   void * jresult ;
21780   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21781   Dali::TypeRegistry *arg2 = 0 ;
21782   Dali::TypeRegistry *result = 0 ;
21783
21784   arg1 = (Dali::TypeRegistry *)jarg1;
21785   arg2 = (Dali::TypeRegistry *)jarg2;
21786   if (!arg2) {
21787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21788     return 0;
21789   }
21790   {
21791     try {
21792       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21793     } catch (std::out_of_range& e) {
21794       {
21795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21796       };
21797     } catch (std::exception& e) {
21798       {
21799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21800       };
21801     } catch (Dali::DaliException e) {
21802       {
21803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21804       };
21805     } catch (...) {
21806       {
21807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21808       };
21809     }
21810   }
21811
21812   jresult = (void *)result;
21813   return jresult;
21814 }
21815
21816
21817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21818   void * jresult ;
21819   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21820   std::string *arg2 = 0 ;
21821   Dali::TypeInfo result;
21822
21823   arg1 = (Dali::TypeRegistry *)jarg1;
21824   if (!jarg2) {
21825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21826     return 0;
21827   }
21828   std::string arg2_str(jarg2);
21829   arg2 = &arg2_str;
21830   {
21831     try {
21832       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21833     } catch (std::out_of_range& e) {
21834       {
21835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21836       };
21837     } catch (std::exception& e) {
21838       {
21839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21840       };
21841     } catch (Dali::DaliException e) {
21842       {
21843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21844       };
21845     } catch (...) {
21846       {
21847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21848       };
21849     }
21850   }
21851
21852   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21853
21854   //argout typemap for const std::string&
21855
21856   return jresult;
21857 }
21858
21859
21860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21861   void * jresult ;
21862   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21863   std::type_info *arg2 = 0 ;
21864   Dali::TypeInfo result;
21865
21866   arg1 = (Dali::TypeRegistry *)jarg1;
21867   arg2 = (std::type_info *)jarg2;
21868   if (!arg2) {
21869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21870     return 0;
21871   }
21872   {
21873     try {
21874       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21875     } catch (std::out_of_range& e) {
21876       {
21877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21878       };
21879     } catch (std::exception& e) {
21880       {
21881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21882       };
21883     } catch (Dali::DaliException e) {
21884       {
21885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21886       };
21887     } catch (...) {
21888       {
21889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21890       };
21891     }
21892   }
21893
21894   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21895   return jresult;
21896 }
21897
21898
21899 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21900   unsigned long jresult ;
21901   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21902   size_t result;
21903
21904   arg1 = (Dali::TypeRegistry *)jarg1;
21905   {
21906     try {
21907       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21908     } catch (std::out_of_range& e) {
21909       {
21910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21911       };
21912     } catch (std::exception& e) {
21913       {
21914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21915       };
21916     } catch (Dali::DaliException e) {
21917       {
21918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21919       };
21920     } catch (...) {
21921       {
21922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21923       };
21924     }
21925   }
21926
21927   jresult = (unsigned long)result;
21928   return jresult;
21929 }
21930
21931
21932 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21933   char * jresult ;
21934   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21935   size_t arg2 ;
21936   std::string result;
21937
21938   arg1 = (Dali::TypeRegistry *)jarg1;
21939   arg2 = (size_t)jarg2;
21940   {
21941     try {
21942       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21943     } catch (std::out_of_range& e) {
21944       {
21945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21946       };
21947     } catch (std::exception& e) {
21948       {
21949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21950       };
21951     } catch (Dali::DaliException e) {
21952       {
21953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21954       };
21955     } catch (...) {
21956       {
21957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21958       };
21959     }
21960   }
21961
21962   jresult = SWIG_csharp_string_callback((&result)->c_str());
21963   return jresult;
21964 }
21965
21966
21967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21968   void * jresult ;
21969   std::type_info *arg1 = 0 ;
21970   std::type_info *arg2 = 0 ;
21971   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21972   Dali::TypeRegistration *result = 0 ;
21973
21974   arg1 = (std::type_info *)jarg1;
21975   if (!arg1) {
21976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21977     return 0;
21978   }
21979   arg2 = (std::type_info *)jarg2;
21980   if (!arg2) {
21981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21982     return 0;
21983   }
21984   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21985   {
21986     try {
21987       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21988     } catch (std::out_of_range& e) {
21989       {
21990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21991       };
21992     } catch (std::exception& e) {
21993       {
21994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21995       };
21996     } catch (Dali::DaliException e) {
21997       {
21998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21999       };
22000     } catch (...) {
22001       {
22002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22003       };
22004     }
22005   }
22006
22007   jresult = (void *)result;
22008   return jresult;
22009 }
22010
22011
22012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22013   void * jresult ;
22014   std::type_info *arg1 = 0 ;
22015   std::type_info *arg2 = 0 ;
22016   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22017   bool arg4 ;
22018   Dali::TypeRegistration *result = 0 ;
22019
22020   arg1 = (std::type_info *)jarg1;
22021   if (!arg1) {
22022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22023     return 0;
22024   }
22025   arg2 = (std::type_info *)jarg2;
22026   if (!arg2) {
22027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22028     return 0;
22029   }
22030   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22031   arg4 = jarg4 ? true : false;
22032   {
22033     try {
22034       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22035     } catch (std::out_of_range& e) {
22036       {
22037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22038       };
22039     } catch (std::exception& e) {
22040       {
22041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22042       };
22043     } catch (Dali::DaliException e) {
22044       {
22045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22046       };
22047     } catch (...) {
22048       {
22049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22050       };
22051     }
22052   }
22053
22054   jresult = (void *)result;
22055   return jresult;
22056 }
22057
22058
22059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22060   void * jresult ;
22061   std::string *arg1 = 0 ;
22062   std::type_info *arg2 = 0 ;
22063   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22064   Dali::TypeRegistration *result = 0 ;
22065
22066   if (!jarg1) {
22067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22068     return 0;
22069   }
22070   std::string arg1_str(jarg1);
22071   arg1 = &arg1_str;
22072   arg2 = (std::type_info *)jarg2;
22073   if (!arg2) {
22074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22075     return 0;
22076   }
22077   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22078   {
22079     try {
22080       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22081     } catch (std::out_of_range& e) {
22082       {
22083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22084       };
22085     } catch (std::exception& e) {
22086       {
22087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22088       };
22089     } catch (Dali::DaliException e) {
22090       {
22091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22092       };
22093     } catch (...) {
22094       {
22095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22096       };
22097     }
22098   }
22099
22100   jresult = (void *)result;
22101
22102   //argout typemap for const std::string&
22103
22104   return jresult;
22105 }
22106
22107
22108 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22109   char * jresult ;
22110   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22111   std::string result;
22112
22113   arg1 = (Dali::TypeRegistration *)jarg1;
22114   {
22115     try {
22116       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22117     } catch (std::out_of_range& e) {
22118       {
22119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22120       };
22121     } catch (std::exception& e) {
22122       {
22123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22124       };
22125     } catch (Dali::DaliException e) {
22126       {
22127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22128       };
22129     } catch (...) {
22130       {
22131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22132       };
22133     }
22134   }
22135
22136   jresult = SWIG_csharp_string_callback((&result)->c_str());
22137   return jresult;
22138 }
22139
22140
22141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22142   std::string *arg1 = 0 ;
22143   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22144
22145   if (!jarg1) {
22146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22147     return ;
22148   }
22149   std::string arg1_str(jarg1);
22150   arg1 = &arg1_str;
22151   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22152   {
22153     try {
22154       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22155     } catch (std::out_of_range& e) {
22156       {
22157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22158       };
22159     } catch (std::exception& e) {
22160       {
22161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22162       };
22163     } catch (Dali::DaliException e) {
22164       {
22165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22166       };
22167     } catch (...) {
22168       {
22169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22170       };
22171     }
22172   }
22173
22174
22175   //argout typemap for const std::string&
22176
22177 }
22178
22179
22180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22181   std::string *arg1 = 0 ;
22182   std::string *arg2 = 0 ;
22183   int arg3 ;
22184   Dali::Property::Type arg4 ;
22185   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22186   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22187
22188   if (!jarg1) {
22189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22190     return ;
22191   }
22192   std::string arg1_str(jarg1);
22193   arg1 = &arg1_str;
22194   if (!jarg2) {
22195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22196     return ;
22197   }
22198   std::string arg2_str(jarg2);
22199   arg2 = &arg2_str;
22200   arg3 = (int)jarg3;
22201   arg4 = (Dali::Property::Type)jarg4;
22202   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22203   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22204   {
22205     try {
22206       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22207     } catch (std::out_of_range& e) {
22208       {
22209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22210       };
22211     } catch (std::exception& e) {
22212       {
22213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22214       };
22215     } catch (Dali::DaliException e) {
22216       {
22217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22218       };
22219     } catch (...) {
22220       {
22221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22222       };
22223     }
22224   }
22225
22226
22227   //argout typemap for const std::string&
22228
22229
22230   //argout typemap for const std::string&
22231
22232 }
22233
22234
22235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22236   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22237
22238   arg1 = (Dali::TypeRegistration *)jarg1;
22239   {
22240     try {
22241       delete arg1;
22242     } catch (std::out_of_range& e) {
22243       {
22244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22245       };
22246     } catch (std::exception& e) {
22247       {
22248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22249       };
22250     } catch (Dali::DaliException e) {
22251       {
22252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22253       };
22254     } catch (...) {
22255       {
22256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22257       };
22258     }
22259   }
22260
22261 }
22262
22263
22264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22265   void * jresult ;
22266   Dali::TypeRegistration *arg1 = 0 ;
22267   std::string *arg2 = 0 ;
22268   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22269   Dali::SignalConnectorType *result = 0 ;
22270
22271   arg1 = (Dali::TypeRegistration *)jarg1;
22272   if (!arg1) {
22273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22274     return 0;
22275   }
22276   if (!jarg2) {
22277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22278     return 0;
22279   }
22280   std::string arg2_str(jarg2);
22281   arg2 = &arg2_str;
22282   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22283   {
22284     try {
22285       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22286     } catch (std::out_of_range& e) {
22287       {
22288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22289       };
22290     } catch (std::exception& e) {
22291       {
22292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22293       };
22294     } catch (Dali::DaliException e) {
22295       {
22296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22297       };
22298     } catch (...) {
22299       {
22300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22301       };
22302     }
22303   }
22304
22305   jresult = (void *)result;
22306
22307   //argout typemap for const std::string&
22308
22309   return jresult;
22310 }
22311
22312
22313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22314   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22315
22316   arg1 = (Dali::SignalConnectorType *)jarg1;
22317   {
22318     try {
22319       delete arg1;
22320     } catch (std::out_of_range& e) {
22321       {
22322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22323       };
22324     } catch (std::exception& e) {
22325       {
22326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22327       };
22328     } catch (Dali::DaliException e) {
22329       {
22330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22331       };
22332     } catch (...) {
22333       {
22334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22335       };
22336     }
22337   }
22338
22339 }
22340
22341
22342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22343   void * jresult ;
22344   Dali::TypeRegistration *arg1 = 0 ;
22345   std::string *arg2 = 0 ;
22346   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22347   Dali::TypeAction *result = 0 ;
22348
22349   arg1 = (Dali::TypeRegistration *)jarg1;
22350   if (!arg1) {
22351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22352     return 0;
22353   }
22354   if (!jarg2) {
22355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22356     return 0;
22357   }
22358   std::string arg2_str(jarg2);
22359   arg2 = &arg2_str;
22360   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22361   {
22362     try {
22363       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22364     } catch (std::out_of_range& e) {
22365       {
22366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22367       };
22368     } catch (std::exception& e) {
22369       {
22370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22371       };
22372     } catch (Dali::DaliException e) {
22373       {
22374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22375       };
22376     } catch (...) {
22377       {
22378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22379       };
22380     }
22381   }
22382
22383   jresult = (void *)result;
22384
22385   //argout typemap for const std::string&
22386
22387   return jresult;
22388 }
22389
22390
22391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22392   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22393
22394   arg1 = (Dali::TypeAction *)jarg1;
22395   {
22396     try {
22397       delete arg1;
22398     } catch (std::out_of_range& e) {
22399       {
22400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22401       };
22402     } catch (std::exception& e) {
22403       {
22404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22405       };
22406     } catch (Dali::DaliException e) {
22407       {
22408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22409       };
22410     } catch (...) {
22411       {
22412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22413       };
22414     }
22415   }
22416
22417 }
22418
22419
22420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22421   void * jresult ;
22422   Dali::TypeRegistration *arg1 = 0 ;
22423   std::string *arg2 = 0 ;
22424   Dali::Property::Index arg3 ;
22425   Dali::Property::Type arg4 ;
22426   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22427   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22428   Dali::PropertyRegistration *result = 0 ;
22429
22430   arg1 = (Dali::TypeRegistration *)jarg1;
22431   if (!arg1) {
22432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22433     return 0;
22434   }
22435   if (!jarg2) {
22436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22437     return 0;
22438   }
22439   std::string arg2_str(jarg2);
22440   arg2 = &arg2_str;
22441   arg3 = (Dali::Property::Index)jarg3;
22442   arg4 = (Dali::Property::Type)jarg4;
22443   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22444   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22445   {
22446     try {
22447       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22448     } catch (std::out_of_range& e) {
22449       {
22450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22451       };
22452     } catch (std::exception& e) {
22453       {
22454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22455       };
22456     } catch (Dali::DaliException e) {
22457       {
22458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22459       };
22460     } catch (...) {
22461       {
22462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22463       };
22464     }
22465   }
22466
22467   jresult = (void *)result;
22468
22469   //argout typemap for const std::string&
22470
22471   return jresult;
22472 }
22473
22474
22475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22476   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22477
22478   arg1 = (Dali::PropertyRegistration *)jarg1;
22479   {
22480     try {
22481       delete arg1;
22482     } catch (std::out_of_range& e) {
22483       {
22484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22485       };
22486     } catch (std::exception& e) {
22487       {
22488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22489       };
22490     } catch (Dali::DaliException e) {
22491       {
22492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22493       };
22494     } catch (...) {
22495       {
22496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22497       };
22498     }
22499   }
22500
22501 }
22502
22503
22504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22505   void * jresult ;
22506   Dali::TypeRegistration *arg1 = 0 ;
22507   std::string *arg2 = 0 ;
22508   Dali::Property::Index arg3 ;
22509   Dali::Property::Type arg4 ;
22510   Dali::AnimatablePropertyRegistration *result = 0 ;
22511
22512   arg1 = (Dali::TypeRegistration *)jarg1;
22513   if (!arg1) {
22514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22515     return 0;
22516   }
22517   if (!jarg2) {
22518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22519     return 0;
22520   }
22521   std::string arg2_str(jarg2);
22522   arg2 = &arg2_str;
22523   arg3 = (Dali::Property::Index)jarg3;
22524   arg4 = (Dali::Property::Type)jarg4;
22525   {
22526     try {
22527       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22528     } catch (std::out_of_range& e) {
22529       {
22530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22531       };
22532     } catch (std::exception& e) {
22533       {
22534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22535       };
22536     } catch (Dali::DaliException e) {
22537       {
22538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22539       };
22540     } catch (...) {
22541       {
22542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22543       };
22544     }
22545   }
22546
22547   jresult = (void *)result;
22548
22549   //argout typemap for const std::string&
22550
22551   return jresult;
22552 }
22553
22554
22555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22556   void * jresult ;
22557   Dali::TypeRegistration *arg1 = 0 ;
22558   std::string *arg2 = 0 ;
22559   Dali::Property::Index arg3 ;
22560   Dali::Property::Value *arg4 = 0 ;
22561   Dali::AnimatablePropertyRegistration *result = 0 ;
22562
22563   arg1 = (Dali::TypeRegistration *)jarg1;
22564   if (!arg1) {
22565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22566     return 0;
22567   }
22568   if (!jarg2) {
22569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22570     return 0;
22571   }
22572   std::string arg2_str(jarg2);
22573   arg2 = &arg2_str;
22574   arg3 = (Dali::Property::Index)jarg3;
22575   arg4 = (Dali::Property::Value *)jarg4;
22576   if (!arg4) {
22577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22578     return 0;
22579   }
22580   {
22581     try {
22582       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22583     } catch (std::out_of_range& e) {
22584       {
22585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22586       };
22587     } catch (std::exception& e) {
22588       {
22589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22590       };
22591     } catch (Dali::DaliException e) {
22592       {
22593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22594       };
22595     } catch (...) {
22596       {
22597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22598       };
22599     }
22600   }
22601
22602   jresult = (void *)result;
22603
22604   //argout typemap for const std::string&
22605
22606   return jresult;
22607 }
22608
22609
22610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22611   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22612
22613   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22614   {
22615     try {
22616       delete arg1;
22617     } catch (std::out_of_range& e) {
22618       {
22619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22620       };
22621     } catch (std::exception& e) {
22622       {
22623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22624       };
22625     } catch (Dali::DaliException e) {
22626       {
22627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22628       };
22629     } catch (...) {
22630       {
22631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22632       };
22633     }
22634   }
22635
22636 }
22637
22638
22639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22640   void * jresult ;
22641   Dali::TypeRegistration *arg1 = 0 ;
22642   std::string *arg2 = 0 ;
22643   Dali::Property::Index arg3 ;
22644   Dali::Property::Index arg4 ;
22645   unsigned int arg5 ;
22646   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22647
22648   arg1 = (Dali::TypeRegistration *)jarg1;
22649   if (!arg1) {
22650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22651     return 0;
22652   }
22653   if (!jarg2) {
22654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22655     return 0;
22656   }
22657   std::string arg2_str(jarg2);
22658   arg2 = &arg2_str;
22659   arg3 = (Dali::Property::Index)jarg3;
22660   arg4 = (Dali::Property::Index)jarg4;
22661   arg5 = (unsigned int)jarg5;
22662   {
22663     try {
22664       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22665     } catch (std::out_of_range& e) {
22666       {
22667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22668       };
22669     } catch (std::exception& e) {
22670       {
22671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22672       };
22673     } catch (Dali::DaliException e) {
22674       {
22675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22676       };
22677     } catch (...) {
22678       {
22679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22680       };
22681     }
22682   }
22683
22684   jresult = (void *)result;
22685
22686   //argout typemap for const std::string&
22687
22688   return jresult;
22689 }
22690
22691
22692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22693   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22694
22695   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22696   {
22697     try {
22698       delete arg1;
22699     } catch (std::out_of_range& e) {
22700       {
22701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22702       };
22703     } catch (std::exception& e) {
22704       {
22705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22706       };
22707     } catch (Dali::DaliException e) {
22708       {
22709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22710       };
22711     } catch (...) {
22712       {
22713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22714       };
22715     }
22716   }
22717
22718 }
22719
22720
22721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22722   void * jresult ;
22723   Dali::TypeRegistration *arg1 = 0 ;
22724   std::string *arg2 = 0 ;
22725   Dali::Property::Index arg3 ;
22726   Dali::Property::Type arg4 ;
22727   Dali::ChildPropertyRegistration *result = 0 ;
22728
22729   arg1 = (Dali::TypeRegistration *)jarg1;
22730   if (!arg1) {
22731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22732     return 0;
22733   }
22734   if (!jarg2) {
22735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22736     return 0;
22737   }
22738   std::string arg2_str(jarg2);
22739   arg2 = &arg2_str;
22740   arg3 = (Dali::Property::Index)jarg3;
22741   arg4 = (Dali::Property::Type)jarg4;
22742   {
22743     try {
22744       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22745     } catch (std::out_of_range& e) {
22746       {
22747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22748       };
22749     } catch (std::exception& e) {
22750       {
22751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22752       };
22753     } catch (Dali::DaliException e) {
22754       {
22755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22756       };
22757     } catch (...) {
22758       {
22759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22760       };
22761     }
22762   }
22763
22764   jresult = (void *)result;
22765
22766   //argout typemap for const std::string&
22767
22768   return jresult;
22769 }
22770
22771
22772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22773   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22774
22775   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22776   {
22777     try {
22778       delete arg1;
22779     } catch (std::out_of_range& e) {
22780       {
22781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22782       };
22783     } catch (std::exception& e) {
22784       {
22785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22786       };
22787     } catch (Dali::DaliException e) {
22788       {
22789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22790       };
22791     } catch (...) {
22792       {
22793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22794       };
22795     }
22796   }
22797
22798 }
22799
22800
22801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22802   unsigned int jresult ;
22803   std::string *arg1 = 0 ;
22804   std::type_info *arg2 = 0 ;
22805   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22806   bool result;
22807
22808   if (!jarg1) {
22809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22810     return 0;
22811   }
22812   std::string arg1_str(jarg1);
22813   arg1 = &arg1_str;
22814   arg2 = (std::type_info *)jarg2;
22815   if (!arg2) {
22816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22817     return 0;
22818   }
22819   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22820   {
22821     try {
22822       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22823     } catch (std::out_of_range& e) {
22824       {
22825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22826       };
22827     } catch (std::exception& e) {
22828       {
22829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22830       };
22831     } catch (Dali::DaliException e) {
22832       {
22833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22834       };
22835     } catch (...) {
22836       {
22837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22838       };
22839     }
22840   }
22841
22842   jresult = result;
22843
22844   //argout typemap for const std::string&
22845
22846   return jresult;
22847 }
22848
22849
22850 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22851   unsigned int jresult ;
22852   std::string *arg1 = 0 ;
22853   std::string *arg2 = 0 ;
22854   Dali::Property::Index arg3 ;
22855   Dali::Property::Type arg4 ;
22856   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22857   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22858   bool result;
22859
22860   if (!jarg1) {
22861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22862     return 0;
22863   }
22864   std::string arg1_str(jarg1);
22865   arg1 = &arg1_str;
22866   if (!jarg2) {
22867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22868     return 0;
22869   }
22870   std::string arg2_str(jarg2);
22871   arg2 = &arg2_str;
22872   arg3 = (Dali::Property::Index)jarg3;
22873   arg4 = (Dali::Property::Type)jarg4;
22874   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22875   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22876   {
22877     try {
22878       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22879     } catch (std::out_of_range& e) {
22880       {
22881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22882       };
22883     } catch (std::exception& e) {
22884       {
22885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22886       };
22887     } catch (Dali::DaliException e) {
22888       {
22889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22890       };
22891     } catch (...) {
22892       {
22893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22894       };
22895     }
22896   }
22897
22898   jresult = result;
22899
22900   //argout typemap for const std::string&
22901
22902
22903   //argout typemap for const std::string&
22904
22905   return jresult;
22906 }
22907
22908
22909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22910   float jresult ;
22911   float result;
22912
22913   result = (float)(float)Dali::ParentOrigin::TOP;
22914   jresult = result;
22915   return jresult;
22916 }
22917
22918
22919 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22920   float jresult ;
22921   float result;
22922
22923   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22924   jresult = result;
22925   return jresult;
22926 }
22927
22928
22929 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22930   float jresult ;
22931   float result;
22932
22933   result = (float)(float)Dali::ParentOrigin::LEFT;
22934   jresult = result;
22935   return jresult;
22936 }
22937
22938
22939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22940   float jresult ;
22941   float result;
22942
22943   result = (float)(float)Dali::ParentOrigin::RIGHT;
22944   jresult = result;
22945   return jresult;
22946 }
22947
22948
22949 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22950   float jresult ;
22951   float result;
22952
22953   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22954   jresult = result;
22955   return jresult;
22956 }
22957
22958
22959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22960   void * jresult ;
22961   Dali::Vector3 *result = 0 ;
22962
22963   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22964   jresult = (void *)result;
22965   return jresult;
22966 }
22967
22968
22969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22970   void * jresult ;
22971   Dali::Vector3 *result = 0 ;
22972
22973   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22974   jresult = (void *)result;
22975   return jresult;
22976 }
22977
22978
22979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22980   void * jresult ;
22981   Dali::Vector3 *result = 0 ;
22982
22983   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22984   jresult = (void *)result;
22985   return jresult;
22986 }
22987
22988
22989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22990   void * jresult ;
22991   Dali::Vector3 *result = 0 ;
22992
22993   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22994   jresult = (void *)result;
22995   return jresult;
22996 }
22997
22998
22999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23000   void * jresult ;
23001   Dali::Vector3 *result = 0 ;
23002
23003   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23004   jresult = (void *)result;
23005   return jresult;
23006 }
23007
23008
23009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23010   void * jresult ;
23011   Dali::Vector3 *result = 0 ;
23012
23013   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23014   jresult = (void *)result;
23015   return jresult;
23016 }
23017
23018
23019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23020   void * jresult ;
23021   Dali::Vector3 *result = 0 ;
23022
23023   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23024   jresult = (void *)result;
23025   return jresult;
23026 }
23027
23028
23029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23030   void * jresult ;
23031   Dali::Vector3 *result = 0 ;
23032
23033   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23034   jresult = (void *)result;
23035   return jresult;
23036 }
23037
23038
23039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23040   void * jresult ;
23041   Dali::Vector3 *result = 0 ;
23042
23043   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23044   jresult = (void *)result;
23045   return jresult;
23046 }
23047
23048
23049 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23050   float jresult ;
23051   float result;
23052
23053   result = (float)(float)Dali::AnchorPoint::TOP;
23054   jresult = result;
23055   return jresult;
23056 }
23057
23058
23059 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23060   float jresult ;
23061   float result;
23062
23063   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23064   jresult = result;
23065   return jresult;
23066 }
23067
23068
23069 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23070   float jresult ;
23071   float result;
23072
23073   result = (float)(float)Dali::AnchorPoint::LEFT;
23074   jresult = result;
23075   return jresult;
23076 }
23077
23078
23079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23080   float jresult ;
23081   float result;
23082
23083   result = (float)(float)Dali::AnchorPoint::RIGHT;
23084   jresult = result;
23085   return jresult;
23086 }
23087
23088
23089 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23090   float jresult ;
23091   float result;
23092
23093   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23094   jresult = result;
23095   return jresult;
23096 }
23097
23098
23099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23100   void * jresult ;
23101   Dali::Vector3 *result = 0 ;
23102
23103   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23104   jresult = (void *)result;
23105   return jresult;
23106 }
23107
23108
23109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23110   void * jresult ;
23111   Dali::Vector3 *result = 0 ;
23112
23113   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23114   jresult = (void *)result;
23115   return jresult;
23116 }
23117
23118
23119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23120   void * jresult ;
23121   Dali::Vector3 *result = 0 ;
23122
23123   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23124   jresult = (void *)result;
23125   return jresult;
23126 }
23127
23128
23129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23130   void * jresult ;
23131   Dali::Vector3 *result = 0 ;
23132
23133   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23134   jresult = (void *)result;
23135   return jresult;
23136 }
23137
23138
23139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23140   void * jresult ;
23141   Dali::Vector3 *result = 0 ;
23142
23143   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23144   jresult = (void *)result;
23145   return jresult;
23146 }
23147
23148
23149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23150   void * jresult ;
23151   Dali::Vector3 *result = 0 ;
23152
23153   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23154   jresult = (void *)result;
23155   return jresult;
23156 }
23157
23158
23159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23160   void * jresult ;
23161   Dali::Vector3 *result = 0 ;
23162
23163   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23164   jresult = (void *)result;
23165   return jresult;
23166 }
23167
23168
23169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23170   void * jresult ;
23171   Dali::Vector3 *result = 0 ;
23172
23173   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23174   jresult = (void *)result;
23175   return jresult;
23176 }
23177
23178
23179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23180   void * jresult ;
23181   Dali::Vector3 *result = 0 ;
23182
23183   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23184   jresult = (void *)result;
23185   return jresult;
23186 }
23187
23188
23189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23190   void * jresult ;
23191   Dali::Vector4 *result = 0 ;
23192
23193   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23194   jresult = (void *)result;
23195   return jresult;
23196 }
23197
23198
23199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23200   void * jresult ;
23201   Dali::Vector4 *result = 0 ;
23202
23203   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23204   jresult = (void *)result;
23205   return jresult;
23206 }
23207
23208
23209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23210   void * jresult ;
23211   Dali::Vector4 *result = 0 ;
23212
23213   result = (Dali::Vector4 *)&Dali::Color::RED;
23214   jresult = (void *)result;
23215   return jresult;
23216 }
23217
23218
23219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23220   void * jresult ;
23221   Dali::Vector4 *result = 0 ;
23222
23223   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23224   jresult = (void *)result;
23225   return jresult;
23226 }
23227
23228
23229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23230   void * jresult ;
23231   Dali::Vector4 *result = 0 ;
23232
23233   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23234   jresult = (void *)result;
23235   return jresult;
23236 }
23237
23238
23239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23240   void * jresult ;
23241   Dali::Vector4 *result = 0 ;
23242
23243   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23244   jresult = (void *)result;
23245   return jresult;
23246 }
23247
23248
23249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23250   void * jresult ;
23251   Dali::Vector4 *result = 0 ;
23252
23253   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23254   jresult = (void *)result;
23255   return jresult;
23256 }
23257
23258
23259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23260   void * jresult ;
23261   Dali::Vector4 *result = 0 ;
23262
23263   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23264   jresult = (void *)result;
23265   return jresult;
23266 }
23267
23268
23269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23270   void * jresult ;
23271   Dali::Vector4 *result = 0 ;
23272
23273   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23274   jresult = (void *)result;
23275   return jresult;
23276 }
23277
23278
23279 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23280   float jresult ;
23281   float result;
23282
23283   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23284   jresult = result;
23285   return jresult;
23286 }
23287
23288
23289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23290   float jresult ;
23291   float result;
23292
23293   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23294   jresult = result;
23295   return jresult;
23296 }
23297
23298
23299 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23300   float jresult ;
23301   float result;
23302
23303   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23304   jresult = result;
23305   return jresult;
23306 }
23307
23308
23309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23310   float jresult ;
23311   float result;
23312
23313   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23314   jresult = result;
23315   return jresult;
23316 }
23317
23318
23319 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23320   float jresult ;
23321   float result;
23322
23323   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23324   jresult = result;
23325   return jresult;
23326 }
23327
23328
23329 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23330   float jresult ;
23331   float result;
23332
23333   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23334   jresult = result;
23335   return jresult;
23336 }
23337
23338
23339 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23340   float jresult ;
23341   float result;
23342
23343   result = (float)(float)Dali::Math::PI;
23344   jresult = result;
23345   return jresult;
23346 }
23347
23348
23349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23350   float jresult ;
23351   float result;
23352
23353   result = (float)(float)Dali::Math::PI_2;
23354   jresult = result;
23355   return jresult;
23356 }
23357
23358
23359 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23360   float jresult ;
23361   float result;
23362
23363   result = (float)(float)Dali::Math::PI_4;
23364   jresult = result;
23365   return jresult;
23366 }
23367
23368
23369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23370   float jresult ;
23371   float result;
23372
23373   result = (float)(float)Dali::Math::PI_OVER_180;
23374   jresult = result;
23375   return jresult;
23376 }
23377
23378
23379 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23380   float jresult ;
23381   float result;
23382
23383   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23384   jresult = result;
23385   return jresult;
23386 }
23387
23388
23389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23390   int jresult ;
23391   Dali::ResizePolicy::Type result;
23392
23393   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23394   jresult = (int)result;
23395   return jresult;
23396 }
23397
23398
23399 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23400   unsigned long jresult ;
23401   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23402   Dali::VectorBase::SizeType result;
23403
23404   arg1 = (Dali::VectorBase *)jarg1;
23405   {
23406     try {
23407       result = ((Dali::VectorBase const *)arg1)->Count();
23408     } catch (std::out_of_range& e) {
23409       {
23410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23411       };
23412     } catch (std::exception& e) {
23413       {
23414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23415       };
23416     } catch (Dali::DaliException e) {
23417       {
23418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23419       };
23420     } catch (...) {
23421       {
23422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23423       };
23424     }
23425   }
23426
23427   jresult = (unsigned long)result;
23428   return jresult;
23429 }
23430
23431
23432 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23433   unsigned long jresult ;
23434   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23435   Dali::VectorBase::SizeType result;
23436
23437   arg1 = (Dali::VectorBase *)jarg1;
23438   {
23439     try {
23440       result = ((Dali::VectorBase const *)arg1)->Size();
23441     } catch (std::out_of_range& e) {
23442       {
23443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23444       };
23445     } catch (std::exception& e) {
23446       {
23447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23448       };
23449     } catch (Dali::DaliException e) {
23450       {
23451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23452       };
23453     } catch (...) {
23454       {
23455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23456       };
23457     }
23458   }
23459
23460   jresult = (unsigned long)result;
23461   return jresult;
23462 }
23463
23464
23465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23466   unsigned int jresult ;
23467   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23468   bool result;
23469
23470   arg1 = (Dali::VectorBase *)jarg1;
23471   {
23472     try {
23473       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23474     } catch (std::out_of_range& e) {
23475       {
23476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23477       };
23478     } catch (std::exception& e) {
23479       {
23480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23481       };
23482     } catch (Dali::DaliException e) {
23483       {
23484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23485       };
23486     } catch (...) {
23487       {
23488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23489       };
23490     }
23491   }
23492
23493   jresult = result;
23494   return jresult;
23495 }
23496
23497
23498 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23499   unsigned long jresult ;
23500   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23501   Dali::VectorBase::SizeType result;
23502
23503   arg1 = (Dali::VectorBase *)jarg1;
23504   {
23505     try {
23506       result = ((Dali::VectorBase const *)arg1)->Capacity();
23507     } catch (std::out_of_range& e) {
23508       {
23509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23510       };
23511     } catch (std::exception& e) {
23512       {
23513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23514       };
23515     } catch (Dali::DaliException e) {
23516       {
23517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23518       };
23519     } catch (...) {
23520       {
23521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23522       };
23523     }
23524   }
23525
23526   jresult = (unsigned long)result;
23527   return jresult;
23528 }
23529
23530
23531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23532   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23533
23534   arg1 = (Dali::VectorBase *)jarg1;
23535   {
23536     try {
23537       (arg1)->Release();
23538     } catch (std::out_of_range& e) {
23539       {
23540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23541       };
23542     } catch (std::exception& e) {
23543       {
23544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23545       };
23546     } catch (Dali::DaliException e) {
23547       {
23548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23549       };
23550     } catch (...) {
23551       {
23552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23553       };
23554     }
23555   }
23556
23557 }
23558
23559
23560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23561   void * jresult ;
23562   Dali::Image *result = 0 ;
23563
23564   {
23565     try {
23566       result = (Dali::Image *)new Dali::Image();
23567     } catch (std::out_of_range& e) {
23568       {
23569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23570       };
23571     } catch (std::exception& e) {
23572       {
23573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23574       };
23575     } catch (Dali::DaliException e) {
23576       {
23577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23578       };
23579     } catch (...) {
23580       {
23581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23582       };
23583     }
23584   }
23585
23586   jresult = (void *)result;
23587   return jresult;
23588 }
23589
23590
23591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23592   Dali::Image *arg1 = (Dali::Image *) 0 ;
23593
23594   arg1 = (Dali::Image *)jarg1;
23595   {
23596     try {
23597       delete arg1;
23598     } catch (std::out_of_range& e) {
23599       {
23600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23601       };
23602     } catch (std::exception& e) {
23603       {
23604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23605       };
23606     } catch (Dali::DaliException e) {
23607       {
23608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23609       };
23610     } catch (...) {
23611       {
23612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23613       };
23614     }
23615   }
23616
23617 }
23618
23619
23620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23621   void * jresult ;
23622   Dali::Image *arg1 = 0 ;
23623   Dali::Image *result = 0 ;
23624
23625   arg1 = (Dali::Image *)jarg1;
23626   if (!arg1) {
23627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23628     return 0;
23629   }
23630   {
23631     try {
23632       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23633     } catch (std::out_of_range& e) {
23634       {
23635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23636       };
23637     } catch (std::exception& e) {
23638       {
23639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23640       };
23641     } catch (Dali::DaliException e) {
23642       {
23643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23644       };
23645     } catch (...) {
23646       {
23647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23648       };
23649     }
23650   }
23651
23652   jresult = (void *)result;
23653   return jresult;
23654 }
23655
23656
23657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23658   void * jresult ;
23659   Dali::Image *arg1 = (Dali::Image *) 0 ;
23660   Dali::Image *arg2 = 0 ;
23661   Dali::Image *result = 0 ;
23662
23663   arg1 = (Dali::Image *)jarg1;
23664   arg2 = (Dali::Image *)jarg2;
23665   if (!arg2) {
23666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23667     return 0;
23668   }
23669   {
23670     try {
23671       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23672     } catch (std::out_of_range& e) {
23673       {
23674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23675       };
23676     } catch (std::exception& e) {
23677       {
23678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23679       };
23680     } catch (Dali::DaliException e) {
23681       {
23682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23683       };
23684     } catch (...) {
23685       {
23686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23687       };
23688     }
23689   }
23690
23691   jresult = (void *)result;
23692   return jresult;
23693 }
23694
23695
23696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23697   void * jresult ;
23698   Dali::BaseHandle arg1 ;
23699   Dali::BaseHandle *argp1 ;
23700   Dali::Image result;
23701
23702   argp1 = (Dali::BaseHandle *)jarg1;
23703   if (!argp1) {
23704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23705     return 0;
23706   }
23707   arg1 = *argp1;
23708   {
23709     try {
23710       result = Dali::Image::DownCast(arg1);
23711     } catch (std::out_of_range& e) {
23712       {
23713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23714       };
23715     } catch (std::exception& e) {
23716       {
23717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23718       };
23719     } catch (Dali::DaliException e) {
23720       {
23721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23722       };
23723     } catch (...) {
23724       {
23725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23726       };
23727     }
23728   }
23729
23730   jresult = new Dali::Image((const Dali::Image &)result);
23731   return jresult;
23732 }
23733
23734
23735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23736   unsigned int jresult ;
23737   Dali::Image *arg1 = (Dali::Image *) 0 ;
23738   unsigned int result;
23739
23740   arg1 = (Dali::Image *)jarg1;
23741   {
23742     try {
23743       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23744     } catch (std::out_of_range& e) {
23745       {
23746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23747       };
23748     } catch (std::exception& e) {
23749       {
23750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23751       };
23752     } catch (Dali::DaliException e) {
23753       {
23754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23755       };
23756     } catch (...) {
23757       {
23758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23759       };
23760     }
23761   }
23762
23763   jresult = result;
23764   return jresult;
23765 }
23766
23767
23768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23769   unsigned int jresult ;
23770   Dali::Image *arg1 = (Dali::Image *) 0 ;
23771   unsigned int result;
23772
23773   arg1 = (Dali::Image *)jarg1;
23774   {
23775     try {
23776       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23777     } catch (std::out_of_range& e) {
23778       {
23779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23780       };
23781     } catch (std::exception& e) {
23782       {
23783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23784       };
23785     } catch (Dali::DaliException e) {
23786       {
23787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23788       };
23789     } catch (...) {
23790       {
23791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23792       };
23793     }
23794   }
23795
23796   jresult = result;
23797   return jresult;
23798 }
23799
23800
23801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23802   void * jresult ;
23803   Dali::Image *arg1 = (Dali::Image *) 0 ;
23804   Dali::Image::ImageSignalType *result = 0 ;
23805
23806   arg1 = (Dali::Image *)jarg1;
23807   {
23808     try {
23809       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23810     } catch (std::out_of_range& e) {
23811       {
23812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23813       };
23814     } catch (std::exception& e) {
23815       {
23816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23817       };
23818     } catch (Dali::DaliException e) {
23819       {
23820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23821       };
23822     } catch (...) {
23823       {
23824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23825       };
23826     }
23827   }
23828
23829   jresult = (void *)result;
23830   return jresult;
23831 }
23832
23833
23834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23835   int jresult ;
23836   Dali::Pixel::Format result;
23837
23838   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23839   jresult = (int)result;
23840   return jresult;
23841 }
23842
23843
23844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23845   int jresult ;
23846   Dali::Pixel::Format result;
23847
23848   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23849   jresult = (int)result;
23850   return jresult;
23851 }
23852
23853
23854 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23855   unsigned int jresult ;
23856   Dali::Pixel::Format arg1 ;
23857   bool result;
23858
23859   arg1 = (Dali::Pixel::Format)jarg1;
23860   {
23861     try {
23862       result = (bool)Dali::Pixel::HasAlpha(arg1);
23863     } catch (std::out_of_range& e) {
23864       {
23865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23866       };
23867     } catch (std::exception& e) {
23868       {
23869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23870       };
23871     } catch (Dali::DaliException e) {
23872       {
23873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23874       };
23875     } catch (...) {
23876       {
23877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23878       };
23879     }
23880   }
23881
23882   jresult = result;
23883   return jresult;
23884 }
23885
23886
23887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23888   unsigned int jresult ;
23889   Dali::Pixel::Format arg1 ;
23890   unsigned int result;
23891
23892   arg1 = (Dali::Pixel::Format)jarg1;
23893   {
23894     try {
23895       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23896     } catch (std::out_of_range& e) {
23897       {
23898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23899       };
23900     } catch (std::exception& e) {
23901       {
23902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23903       };
23904     } catch (Dali::DaliException e) {
23905       {
23906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23907       };
23908     } catch (...) {
23909       {
23910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23911       };
23912     }
23913   }
23914
23915   jresult = result;
23916   return jresult;
23917 }
23918
23919
23920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23921   Dali::Pixel::Format arg1 ;
23922   int *arg2 = 0 ;
23923   int *arg3 = 0 ;
23924
23925   arg1 = (Dali::Pixel::Format)jarg1;
23926   arg2 = (int *)jarg2;
23927   if (!arg2) {
23928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23929     return ;
23930   }
23931   arg3 = (int *)jarg3;
23932   if (!arg3) {
23933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23934     return ;
23935   }
23936   {
23937     try {
23938       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23939     } catch (std::out_of_range& e) {
23940       {
23941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23942       };
23943     } catch (std::exception& e) {
23944       {
23945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23946       };
23947     } catch (Dali::DaliException e) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23950       };
23951     } catch (...) {
23952       {
23953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23954       };
23955     }
23956   }
23957
23958 }
23959
23960
23961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23962   void * jresult ;
23963   unsigned char *arg1 = (unsigned char *) 0 ;
23964   unsigned int arg2 ;
23965   unsigned int arg3 ;
23966   unsigned int arg4 ;
23967   Dali::Pixel::Format arg5 ;
23968   Dali::PixelData::ReleaseFunction arg6 ;
23969   Dali::PixelData result;
23970
23971   arg1 = jarg1;
23972   arg2 = (unsigned int)jarg2;
23973   arg3 = (unsigned int)jarg3;
23974   arg4 = (unsigned int)jarg4;
23975   arg5 = (Dali::Pixel::Format)jarg5;
23976   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23977   {
23978     try {
23979       auto pixelBuffer = new unsigned char[jarg2];
23980       memcpy( pixelBuffer, arg1, arg2);
23981       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23982     } catch (std::out_of_range& e) {
23983       {
23984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23985       };
23986     } catch (std::exception& e) {
23987       {
23988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23989       };
23990     } catch (Dali::DaliException e) {
23991       {
23992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23993       };
23994     } catch (...) {
23995       {
23996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23997       };
23998     }
23999   }
24000
24001   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24002
24003
24004   return jresult;
24005 }
24006
24007
24008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24009   void * jresult ;
24010   Dali::PixelData *result = 0 ;
24011
24012   {
24013     try {
24014       result = (Dali::PixelData *)new Dali::PixelData();
24015     } catch (std::out_of_range& e) {
24016       {
24017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24018       };
24019     } catch (std::exception& e) {
24020       {
24021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24022       };
24023     } catch (Dali::DaliException e) {
24024       {
24025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24026       };
24027     } catch (...) {
24028       {
24029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24030       };
24031     }
24032   }
24033
24034   jresult = (void *)result;
24035   return jresult;
24036 }
24037
24038
24039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24040   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24041
24042   arg1 = (Dali::PixelData *)jarg1;
24043   {
24044     try {
24045       delete arg1;
24046     } catch (std::out_of_range& e) {
24047       {
24048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24049       };
24050     } catch (std::exception& e) {
24051       {
24052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24053       };
24054     } catch (Dali::DaliException e) {
24055       {
24056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24057       };
24058     } catch (...) {
24059       {
24060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24061       };
24062     }
24063   }
24064
24065 }
24066
24067
24068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24069   void * jresult ;
24070   Dali::PixelData *arg1 = 0 ;
24071   Dali::PixelData *result = 0 ;
24072
24073   arg1 = (Dali::PixelData *)jarg1;
24074   if (!arg1) {
24075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24076     return 0;
24077   }
24078   {
24079     try {
24080       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24081     } catch (std::out_of_range& e) {
24082       {
24083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24084       };
24085     } catch (std::exception& e) {
24086       {
24087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24088       };
24089     } catch (Dali::DaliException e) {
24090       {
24091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24092       };
24093     } catch (...) {
24094       {
24095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24096       };
24097     }
24098   }
24099
24100   jresult = (void *)result;
24101   return jresult;
24102 }
24103
24104
24105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24106   void * jresult ;
24107   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24108   Dali::PixelData *arg2 = 0 ;
24109   Dali::PixelData *result = 0 ;
24110
24111   arg1 = (Dali::PixelData *)jarg1;
24112   arg2 = (Dali::PixelData *)jarg2;
24113   if (!arg2) {
24114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24115     return 0;
24116   }
24117   {
24118     try {
24119       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24120     } catch (std::out_of_range& e) {
24121       {
24122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24123       };
24124     } catch (std::exception& e) {
24125       {
24126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24127       };
24128     } catch (Dali::DaliException e) {
24129       {
24130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24131       };
24132     } catch (...) {
24133       {
24134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24135       };
24136     }
24137   }
24138
24139   jresult = (void *)result;
24140   return jresult;
24141 }
24142
24143
24144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24145   unsigned int jresult ;
24146   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24147   unsigned int result;
24148
24149   arg1 = (Dali::PixelData *)jarg1;
24150   {
24151     try {
24152       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24153     } catch (std::out_of_range& e) {
24154       {
24155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24156       };
24157     } catch (std::exception& e) {
24158       {
24159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24160       };
24161     } catch (Dali::DaliException e) {
24162       {
24163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24164       };
24165     } catch (...) {
24166       {
24167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24168       };
24169     }
24170   }
24171
24172   jresult = result;
24173   return jresult;
24174 }
24175
24176
24177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24178   unsigned int jresult ;
24179   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24180   unsigned int result;
24181
24182   arg1 = (Dali::PixelData *)jarg1;
24183   {
24184     try {
24185       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24186     } catch (std::out_of_range& e) {
24187       {
24188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24189       };
24190     } catch (std::exception& e) {
24191       {
24192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24193       };
24194     } catch (Dali::DaliException e) {
24195       {
24196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24197       };
24198     } catch (...) {
24199       {
24200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24201       };
24202     }
24203   }
24204
24205   jresult = result;
24206   return jresult;
24207 }
24208
24209
24210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24211   int jresult ;
24212   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24213   Dali::Pixel::Format result;
24214
24215   arg1 = (Dali::PixelData *)jarg1;
24216   {
24217     try {
24218       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24219     } catch (std::out_of_range& e) {
24220       {
24221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24222       };
24223     } catch (std::exception& e) {
24224       {
24225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24226       };
24227     } catch (Dali::DaliException e) {
24228       {
24229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24230       };
24231     } catch (...) {
24232       {
24233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24234       };
24235     }
24236   }
24237
24238   jresult = (int)result;
24239   return jresult;
24240 }
24241
24242
24243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24244   unsigned int jresult ;
24245   unsigned int result;
24246
24247   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24248   jresult = result;
24249   return jresult;
24250 }
24251
24252
24253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24254   unsigned int jresult ;
24255   unsigned int result;
24256
24257   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24258   jresult = result;
24259   return jresult;
24260 }
24261
24262
24263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24264   unsigned int jresult ;
24265   unsigned int result;
24266
24267   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24268   jresult = result;
24269   return jresult;
24270 }
24271
24272
24273 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24274   unsigned int jresult ;
24275   unsigned int result;
24276
24277   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24278   jresult = result;
24279   return jresult;
24280 }
24281
24282
24283 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24284   unsigned int jresult ;
24285   unsigned int result;
24286
24287   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24288   jresult = result;
24289   return jresult;
24290 }
24291
24292
24293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24294   unsigned int jresult ;
24295   unsigned int result;
24296
24297   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24298   jresult = result;
24299   return jresult;
24300 }
24301
24302
24303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24304   void * jresult ;
24305   Dali::TextureType::Type arg1 ;
24306   Dali::Pixel::Format arg2 ;
24307   unsigned int arg3 ;
24308   unsigned int arg4 ;
24309   Dali::Texture result;
24310
24311   arg1 = (Dali::TextureType::Type)jarg1;
24312   arg2 = (Dali::Pixel::Format)jarg2;
24313   arg3 = (unsigned int)jarg3;
24314   arg4 = (unsigned int)jarg4;
24315   {
24316     try {
24317       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24318     } catch (std::out_of_range& e) {
24319       {
24320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24321       };
24322     } catch (std::exception& e) {
24323       {
24324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24325       };
24326     } catch (Dali::DaliException e) {
24327       {
24328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24329       };
24330     } catch (...) {
24331       {
24332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24333       };
24334     }
24335   }
24336
24337   jresult = new Dali::Texture((const Dali::Texture &)result);
24338   return jresult;
24339 }
24340
24341
24342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24343   void * jresult ;
24344   NativeImageInterface *arg1 = 0 ;
24345   Dali::Texture result;
24346
24347   arg1 = (NativeImageInterface *)jarg1;
24348   if (!arg1) {
24349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24350     return 0;
24351   }
24352   {
24353     try {
24354       result = Dali::Texture::New(*arg1);
24355     } catch (std::out_of_range& e) {
24356       {
24357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24358       };
24359     } catch (std::exception& e) {
24360       {
24361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24362       };
24363     } catch (Dali::DaliException e) {
24364       {
24365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24366       };
24367     } catch (...) {
24368       {
24369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24370       };
24371     }
24372   }
24373
24374   jresult = new Dali::Texture((const Dali::Texture &)result);
24375   return jresult;
24376 }
24377
24378
24379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24380   void * jresult ;
24381   Dali::Texture *result = 0 ;
24382
24383   {
24384     try {
24385       result = (Dali::Texture *)new Dali::Texture();
24386     } catch (std::out_of_range& e) {
24387       {
24388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24389       };
24390     } catch (std::exception& e) {
24391       {
24392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24393       };
24394     } catch (Dali::DaliException e) {
24395       {
24396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24397       };
24398     } catch (...) {
24399       {
24400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24401       };
24402     }
24403   }
24404
24405   jresult = (void *)result;
24406   return jresult;
24407 }
24408
24409
24410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24411   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24412
24413   arg1 = (Dali::Texture *)jarg1;
24414   {
24415     try {
24416       delete arg1;
24417     } catch (std::out_of_range& e) {
24418       {
24419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24420       };
24421     } catch (std::exception& e) {
24422       {
24423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24424       };
24425     } catch (Dali::DaliException e) {
24426       {
24427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24428       };
24429     } catch (...) {
24430       {
24431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24432       };
24433     }
24434   }
24435
24436 }
24437
24438
24439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24440   void * jresult ;
24441   Dali::Texture *arg1 = 0 ;
24442   Dali::Texture *result = 0 ;
24443
24444   arg1 = (Dali::Texture *)jarg1;
24445   if (!arg1) {
24446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24447     return 0;
24448   }
24449   {
24450     try {
24451       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24452     } catch (std::out_of_range& e) {
24453       {
24454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24455       };
24456     } catch (std::exception& e) {
24457       {
24458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24459       };
24460     } catch (Dali::DaliException e) {
24461       {
24462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24463       };
24464     } catch (...) {
24465       {
24466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24467       };
24468     }
24469   }
24470
24471   jresult = (void *)result;
24472   return jresult;
24473 }
24474
24475
24476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24477   void * jresult ;
24478   Dali::BaseHandle arg1 ;
24479   Dali::BaseHandle *argp1 ;
24480   Dali::Texture result;
24481
24482   argp1 = (Dali::BaseHandle *)jarg1;
24483   if (!argp1) {
24484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24485     return 0;
24486   }
24487   arg1 = *argp1;
24488   {
24489     try {
24490       result = Dali::Texture::DownCast(arg1);
24491     } catch (std::out_of_range& e) {
24492       {
24493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24494       };
24495     } catch (std::exception& e) {
24496       {
24497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24498       };
24499     } catch (Dali::DaliException e) {
24500       {
24501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24502       };
24503     } catch (...) {
24504       {
24505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24506       };
24507     }
24508   }
24509
24510   jresult = new Dali::Texture((const Dali::Texture &)result);
24511   return jresult;
24512 }
24513
24514
24515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24516   void * jresult ;
24517   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24518   Dali::Texture *arg2 = 0 ;
24519   Dali::Texture *result = 0 ;
24520
24521   arg1 = (Dali::Texture *)jarg1;
24522   arg2 = (Dali::Texture *)jarg2;
24523   if (!arg2) {
24524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24525     return 0;
24526   }
24527   {
24528     try {
24529       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24530     } catch (std::out_of_range& e) {
24531       {
24532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24533       };
24534     } catch (std::exception& e) {
24535       {
24536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24537       };
24538     } catch (Dali::DaliException e) {
24539       {
24540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24541       };
24542     } catch (...) {
24543       {
24544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24545       };
24546     }
24547   }
24548
24549   jresult = (void *)result;
24550   return jresult;
24551 }
24552
24553
24554 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24555   unsigned int jresult ;
24556   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24557   Dali::PixelData arg2 ;
24558   Dali::PixelData *argp2 ;
24559   bool result;
24560
24561   arg1 = (Dali::Texture *)jarg1;
24562   argp2 = (Dali::PixelData *)jarg2;
24563   if (!argp2) {
24564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24565     return 0;
24566   }
24567   arg2 = *argp2;
24568   {
24569     try {
24570       result = (bool)(arg1)->Upload(arg2);
24571     } catch (std::out_of_range& e) {
24572       {
24573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24574       };
24575     } catch (std::exception& e) {
24576       {
24577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24578       };
24579     } catch (Dali::DaliException e) {
24580       {
24581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24582       };
24583     } catch (...) {
24584       {
24585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24586       };
24587     }
24588   }
24589
24590   jresult = result;
24591   return jresult;
24592 }
24593
24594
24595 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) {
24596   unsigned int jresult ;
24597   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24598   Dali::PixelData arg2 ;
24599   unsigned int arg3 ;
24600   unsigned int arg4 ;
24601   unsigned int arg5 ;
24602   unsigned int arg6 ;
24603   unsigned int arg7 ;
24604   unsigned int arg8 ;
24605   Dali::PixelData *argp2 ;
24606   bool result;
24607
24608   arg1 = (Dali::Texture *)jarg1;
24609   argp2 = (Dali::PixelData *)jarg2;
24610   if (!argp2) {
24611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24612     return 0;
24613   }
24614   arg2 = *argp2;
24615   arg3 = (unsigned int)jarg3;
24616   arg4 = (unsigned int)jarg4;
24617   arg5 = (unsigned int)jarg5;
24618   arg6 = (unsigned int)jarg6;
24619   arg7 = (unsigned int)jarg7;
24620   arg8 = (unsigned int)jarg8;
24621   {
24622     try {
24623       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24624     } catch (std::out_of_range& e) {
24625       {
24626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24627       };
24628     } catch (std::exception& e) {
24629       {
24630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24631       };
24632     } catch (Dali::DaliException e) {
24633       {
24634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24635       };
24636     } catch (...) {
24637       {
24638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24639       };
24640     }
24641   }
24642
24643   jresult = result;
24644   return jresult;
24645 }
24646
24647
24648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24649   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24650
24651   arg1 = (Dali::Texture *)jarg1;
24652   {
24653     try {
24654       (arg1)->GenerateMipmaps();
24655     } catch (std::out_of_range& e) {
24656       {
24657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24658       };
24659     } catch (std::exception& e) {
24660       {
24661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24662       };
24663     } catch (Dali::DaliException e) {
24664       {
24665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24666       };
24667     } catch (...) {
24668       {
24669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24670       };
24671     }
24672   }
24673
24674 }
24675
24676
24677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24678   unsigned int jresult ;
24679   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24680   unsigned int result;
24681
24682   arg1 = (Dali::Texture *)jarg1;
24683   {
24684     try {
24685       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24686     } catch (std::out_of_range& e) {
24687       {
24688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24689       };
24690     } catch (std::exception& e) {
24691       {
24692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24693       };
24694     } catch (Dali::DaliException e) {
24695       {
24696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24697       };
24698     } catch (...) {
24699       {
24700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24701       };
24702     }
24703   }
24704
24705   jresult = result;
24706   return jresult;
24707 }
24708
24709
24710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24711   unsigned int jresult ;
24712   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24713   unsigned int result;
24714
24715   arg1 = (Dali::Texture *)jarg1;
24716   {
24717     try {
24718       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24719     } catch (std::out_of_range& e) {
24720       {
24721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24722       };
24723     } catch (std::exception& e) {
24724       {
24725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24726       };
24727     } catch (Dali::DaliException e) {
24728       {
24729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24730       };
24731     } catch (...) {
24732       {
24733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24734       };
24735     }
24736   }
24737
24738   jresult = result;
24739   return jresult;
24740 }
24741
24742
24743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24744   void * jresult ;
24745   Dali::Sampler result;
24746
24747   {
24748     try {
24749       result = Dali::Sampler::New();
24750     } catch (std::out_of_range& e) {
24751       {
24752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24753       };
24754     } catch (std::exception& e) {
24755       {
24756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24757       };
24758     } catch (Dali::DaliException e) {
24759       {
24760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24761       };
24762     } catch (...) {
24763       {
24764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24765       };
24766     }
24767   }
24768
24769   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24770   return jresult;
24771 }
24772
24773
24774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24775   void * jresult ;
24776   Dali::Sampler *result = 0 ;
24777
24778   {
24779     try {
24780       result = (Dali::Sampler *)new Dali::Sampler();
24781     } catch (std::out_of_range& e) {
24782       {
24783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24784       };
24785     } catch (std::exception& e) {
24786       {
24787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24788       };
24789     } catch (Dali::DaliException e) {
24790       {
24791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24792       };
24793     } catch (...) {
24794       {
24795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24796       };
24797     }
24798   }
24799
24800   jresult = (void *)result;
24801   return jresult;
24802 }
24803
24804
24805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24806   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24807
24808   arg1 = (Dali::Sampler *)jarg1;
24809   {
24810     try {
24811       delete arg1;
24812     } catch (std::out_of_range& e) {
24813       {
24814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24815       };
24816     } catch (std::exception& e) {
24817       {
24818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24819       };
24820     } catch (Dali::DaliException e) {
24821       {
24822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24823       };
24824     } catch (...) {
24825       {
24826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24827       };
24828     }
24829   }
24830
24831 }
24832
24833
24834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24835   void * jresult ;
24836   Dali::Sampler *arg1 = 0 ;
24837   Dali::Sampler *result = 0 ;
24838
24839   arg1 = (Dali::Sampler *)jarg1;
24840   if (!arg1) {
24841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24842     return 0;
24843   }
24844   {
24845     try {
24846       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24847     } catch (std::out_of_range& e) {
24848       {
24849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24850       };
24851     } catch (std::exception& e) {
24852       {
24853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24854       };
24855     } catch (Dali::DaliException e) {
24856       {
24857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24858       };
24859     } catch (...) {
24860       {
24861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24862       };
24863     }
24864   }
24865
24866   jresult = (void *)result;
24867   return jresult;
24868 }
24869
24870
24871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24872   void * jresult ;
24873   Dali::BaseHandle arg1 ;
24874   Dali::BaseHandle *argp1 ;
24875   Dali::Sampler result;
24876
24877   argp1 = (Dali::BaseHandle *)jarg1;
24878   if (!argp1) {
24879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24880     return 0;
24881   }
24882   arg1 = *argp1;
24883   {
24884     try {
24885       result = Dali::Sampler::DownCast(arg1);
24886     } catch (std::out_of_range& e) {
24887       {
24888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24889       };
24890     } catch (std::exception& e) {
24891       {
24892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24893       };
24894     } catch (Dali::DaliException e) {
24895       {
24896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24897       };
24898     } catch (...) {
24899       {
24900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24901       };
24902     }
24903   }
24904
24905   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24906   return jresult;
24907 }
24908
24909
24910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24911   void * jresult ;
24912   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24913   Dali::Sampler *arg2 = 0 ;
24914   Dali::Sampler *result = 0 ;
24915
24916   arg1 = (Dali::Sampler *)jarg1;
24917   arg2 = (Dali::Sampler *)jarg2;
24918   if (!arg2) {
24919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24920     return 0;
24921   }
24922   {
24923     try {
24924       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24925     } catch (std::out_of_range& e) {
24926       {
24927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24928       };
24929     } catch (std::exception& e) {
24930       {
24931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24932       };
24933     } catch (Dali::DaliException e) {
24934       {
24935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24936       };
24937     } catch (...) {
24938       {
24939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24940       };
24941     }
24942   }
24943
24944   jresult = (void *)result;
24945   return jresult;
24946 }
24947
24948
24949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24950   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24951   Dali::FilterMode::Type arg2 ;
24952   Dali::FilterMode::Type arg3 ;
24953
24954   arg1 = (Dali::Sampler *)jarg1;
24955   arg2 = (Dali::FilterMode::Type)jarg2;
24956   arg3 = (Dali::FilterMode::Type)jarg3;
24957   {
24958     try {
24959       (arg1)->SetFilterMode(arg2,arg3);
24960     } catch (std::out_of_range& e) {
24961       {
24962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24963       };
24964     } catch (std::exception& e) {
24965       {
24966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24967       };
24968     } catch (Dali::DaliException e) {
24969       {
24970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24971       };
24972     } catch (...) {
24973       {
24974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24975       };
24976     }
24977   }
24978
24979 }
24980
24981
24982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24983   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24984   Dali::WrapMode::Type arg2 ;
24985   Dali::WrapMode::Type arg3 ;
24986
24987   arg1 = (Dali::Sampler *)jarg1;
24988   arg2 = (Dali::WrapMode::Type)jarg2;
24989   arg3 = (Dali::WrapMode::Type)jarg3;
24990   {
24991     try {
24992       (arg1)->SetWrapMode(arg2,arg3);
24993     } catch (std::out_of_range& e) {
24994       {
24995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24996       };
24997     } catch (std::exception& e) {
24998       {
24999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25000       };
25001     } catch (Dali::DaliException e) {
25002       {
25003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25004       };
25005     } catch (...) {
25006       {
25007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25008       };
25009     }
25010   }
25011
25012 }
25013
25014
25015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25016   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25017   Dali::WrapMode::Type arg2 ;
25018   Dali::WrapMode::Type arg3 ;
25019   Dali::WrapMode::Type arg4 ;
25020
25021   arg1 = (Dali::Sampler *)jarg1;
25022   arg2 = (Dali::WrapMode::Type)jarg2;
25023   arg3 = (Dali::WrapMode::Type)jarg3;
25024   arg4 = (Dali::WrapMode::Type)jarg4;
25025   {
25026     try {
25027       (arg1)->SetWrapMode(arg2,arg3,arg4);
25028     } catch (std::out_of_range& e) {
25029       {
25030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25031       };
25032     } catch (std::exception& e) {
25033       {
25034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25035       };
25036     } catch (Dali::DaliException e) {
25037       {
25038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25039       };
25040     } catch (...) {
25041       {
25042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25043       };
25044     }
25045   }
25046
25047 }
25048
25049
25050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25051   void * jresult ;
25052   Dali::TextureSet result;
25053
25054   {
25055     try {
25056       result = Dali::TextureSet::New();
25057     } catch (std::out_of_range& e) {
25058       {
25059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25060       };
25061     } catch (std::exception& e) {
25062       {
25063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25064       };
25065     } catch (Dali::DaliException e) {
25066       {
25067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25068       };
25069     } catch (...) {
25070       {
25071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25072       };
25073     }
25074   }
25075
25076   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25077   return jresult;
25078 }
25079
25080
25081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25082   void * jresult ;
25083   Dali::TextureSet *result = 0 ;
25084
25085   {
25086     try {
25087       result = (Dali::TextureSet *)new Dali::TextureSet();
25088     } catch (std::out_of_range& e) {
25089       {
25090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25091       };
25092     } catch (std::exception& e) {
25093       {
25094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25095       };
25096     } catch (Dali::DaliException e) {
25097       {
25098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25099       };
25100     } catch (...) {
25101       {
25102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25103       };
25104     }
25105   }
25106
25107   jresult = (void *)result;
25108   return jresult;
25109 }
25110
25111
25112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25113   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25114
25115   arg1 = (Dali::TextureSet *)jarg1;
25116   {
25117     try {
25118       delete arg1;
25119     } catch (std::out_of_range& e) {
25120       {
25121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25122       };
25123     } catch (std::exception& e) {
25124       {
25125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25126       };
25127     } catch (Dali::DaliException e) {
25128       {
25129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25130       };
25131     } catch (...) {
25132       {
25133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25134       };
25135     }
25136   }
25137
25138 }
25139
25140
25141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25142   void * jresult ;
25143   Dali::TextureSet *arg1 = 0 ;
25144   Dali::TextureSet *result = 0 ;
25145
25146   arg1 = (Dali::TextureSet *)jarg1;
25147   if (!arg1) {
25148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25149     return 0;
25150   }
25151   {
25152     try {
25153       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25154     } catch (std::out_of_range& e) {
25155       {
25156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25157       };
25158     } catch (std::exception& e) {
25159       {
25160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25161       };
25162     } catch (Dali::DaliException e) {
25163       {
25164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25165       };
25166     } catch (...) {
25167       {
25168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25169       };
25170     }
25171   }
25172
25173   jresult = (void *)result;
25174   return jresult;
25175 }
25176
25177
25178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25179   void * jresult ;
25180   Dali::BaseHandle arg1 ;
25181   Dali::BaseHandle *argp1 ;
25182   Dali::TextureSet result;
25183
25184   argp1 = (Dali::BaseHandle *)jarg1;
25185   if (!argp1) {
25186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25187     return 0;
25188   }
25189   arg1 = *argp1;
25190   {
25191     try {
25192       result = Dali::TextureSet::DownCast(arg1);
25193     } catch (std::out_of_range& e) {
25194       {
25195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25196       };
25197     } catch (std::exception& e) {
25198       {
25199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25200       };
25201     } catch (Dali::DaliException e) {
25202       {
25203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25204       };
25205     } catch (...) {
25206       {
25207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25208       };
25209     }
25210   }
25211
25212   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25213   return jresult;
25214 }
25215
25216
25217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25218   void * jresult ;
25219   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25220   Dali::TextureSet *arg2 = 0 ;
25221   Dali::TextureSet *result = 0 ;
25222
25223   arg1 = (Dali::TextureSet *)jarg1;
25224   arg2 = (Dali::TextureSet *)jarg2;
25225   if (!arg2) {
25226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25227     return 0;
25228   }
25229   {
25230     try {
25231       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25232     } catch (std::out_of_range& e) {
25233       {
25234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25235       };
25236     } catch (std::exception& e) {
25237       {
25238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25239       };
25240     } catch (Dali::DaliException e) {
25241       {
25242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25243       };
25244     } catch (...) {
25245       {
25246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25247       };
25248     }
25249   }
25250
25251   jresult = (void *)result;
25252   return jresult;
25253 }
25254
25255
25256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25257   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25258   size_t arg2 ;
25259   Dali::Texture arg3 ;
25260   Dali::Texture *argp3 ;
25261
25262   arg1 = (Dali::TextureSet *)jarg1;
25263   arg2 = (size_t)jarg2;
25264   argp3 = (Dali::Texture *)jarg3;
25265   if (!argp3) {
25266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25267     return ;
25268   }
25269   arg3 = *argp3;
25270   {
25271     try {
25272       (arg1)->SetTexture(arg2,arg3);
25273     } catch (std::out_of_range& e) {
25274       {
25275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25276       };
25277     } catch (std::exception& e) {
25278       {
25279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25280       };
25281     } catch (Dali::DaliException e) {
25282       {
25283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25284       };
25285     } catch (...) {
25286       {
25287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25288       };
25289     }
25290   }
25291
25292 }
25293
25294
25295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25296   void * jresult ;
25297   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25298   size_t arg2 ;
25299   Dali::Texture result;
25300
25301   arg1 = (Dali::TextureSet *)jarg1;
25302   arg2 = (size_t)jarg2;
25303   {
25304     try {
25305       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25306     } catch (std::out_of_range& e) {
25307       {
25308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25309       };
25310     } catch (std::exception& e) {
25311       {
25312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25313       };
25314     } catch (Dali::DaliException e) {
25315       {
25316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25317       };
25318     } catch (...) {
25319       {
25320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25321       };
25322     }
25323   }
25324
25325   jresult = new Dali::Texture((const Dali::Texture &)result);
25326   return jresult;
25327 }
25328
25329
25330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25331   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25332   size_t arg2 ;
25333   Dali::Sampler arg3 ;
25334   Dali::Sampler *argp3 ;
25335
25336   arg1 = (Dali::TextureSet *)jarg1;
25337   arg2 = (size_t)jarg2;
25338   argp3 = (Dali::Sampler *)jarg3;
25339   if (!argp3) {
25340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25341     return ;
25342   }
25343   arg3 = *argp3;
25344   {
25345     try {
25346       (arg1)->SetSampler(arg2,arg3);
25347     } catch (std::out_of_range& e) {
25348       {
25349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25350       };
25351     } catch (std::exception& e) {
25352       {
25353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25354       };
25355     } catch (Dali::DaliException e) {
25356       {
25357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25358       };
25359     } catch (...) {
25360       {
25361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25362       };
25363     }
25364   }
25365
25366 }
25367
25368
25369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25370   void * jresult ;
25371   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25372   size_t arg2 ;
25373   Dali::Sampler result;
25374
25375   arg1 = (Dali::TextureSet *)jarg1;
25376   arg2 = (size_t)jarg2;
25377   {
25378     try {
25379       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25380     } catch (std::out_of_range& e) {
25381       {
25382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25383       };
25384     } catch (std::exception& e) {
25385       {
25386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25387       };
25388     } catch (Dali::DaliException e) {
25389       {
25390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25391       };
25392     } catch (...) {
25393       {
25394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25395       };
25396     }
25397   }
25398
25399   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25400   return jresult;
25401 }
25402
25403
25404 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25405   unsigned long jresult ;
25406   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25407   size_t result;
25408
25409   arg1 = (Dali::TextureSet *)jarg1;
25410   {
25411     try {
25412       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25413     } catch (std::out_of_range& e) {
25414       {
25415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25416       };
25417     } catch (std::exception& e) {
25418       {
25419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25420       };
25421     } catch (Dali::DaliException e) {
25422       {
25423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25424       };
25425     } catch (...) {
25426       {
25427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25428       };
25429     }
25430   }
25431
25432   jresult = (unsigned long)result;
25433   return jresult;
25434 }
25435
25436
25437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25438   void * jresult ;
25439   Dali::Property::Map *arg1 = 0 ;
25440   Dali::PropertyBuffer result;
25441
25442   arg1 = (Dali::Property::Map *)jarg1;
25443   if (!arg1) {
25444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25445     return 0;
25446   }
25447   {
25448     try {
25449       result = Dali::PropertyBuffer::New(*arg1);
25450     } catch (std::out_of_range& e) {
25451       {
25452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25453       };
25454     } catch (std::exception& e) {
25455       {
25456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25457       };
25458     } catch (Dali::DaliException e) {
25459       {
25460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25461       };
25462     } catch (...) {
25463       {
25464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25465       };
25466     }
25467   }
25468
25469   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25470   return jresult;
25471 }
25472
25473
25474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25475   void * jresult ;
25476   Dali::PropertyBuffer *result = 0 ;
25477
25478   {
25479     try {
25480       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25481     } catch (std::out_of_range& e) {
25482       {
25483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25484       };
25485     } catch (std::exception& e) {
25486       {
25487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25488       };
25489     } catch (Dali::DaliException e) {
25490       {
25491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25492       };
25493     } catch (...) {
25494       {
25495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25496       };
25497     }
25498   }
25499
25500   jresult = (void *)result;
25501   return jresult;
25502 }
25503
25504
25505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25506   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25507
25508   arg1 = (Dali::PropertyBuffer *)jarg1;
25509   {
25510     try {
25511       delete arg1;
25512     } catch (std::out_of_range& e) {
25513       {
25514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25515       };
25516     } catch (std::exception& e) {
25517       {
25518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25519       };
25520     } catch (Dali::DaliException e) {
25521       {
25522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25523       };
25524     } catch (...) {
25525       {
25526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25527       };
25528     }
25529   }
25530
25531 }
25532
25533
25534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25535   void * jresult ;
25536   Dali::PropertyBuffer *arg1 = 0 ;
25537   Dali::PropertyBuffer *result = 0 ;
25538
25539   arg1 = (Dali::PropertyBuffer *)jarg1;
25540   if (!arg1) {
25541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25542     return 0;
25543   }
25544   {
25545     try {
25546       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25547     } catch (std::out_of_range& e) {
25548       {
25549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25550       };
25551     } catch (std::exception& e) {
25552       {
25553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25554       };
25555     } catch (Dali::DaliException e) {
25556       {
25557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25558       };
25559     } catch (...) {
25560       {
25561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25562       };
25563     }
25564   }
25565
25566   jresult = (void *)result;
25567   return jresult;
25568 }
25569
25570
25571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25572   void * jresult ;
25573   Dali::BaseHandle arg1 ;
25574   Dali::BaseHandle *argp1 ;
25575   Dali::PropertyBuffer result;
25576
25577   argp1 = (Dali::BaseHandle *)jarg1;
25578   if (!argp1) {
25579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25580     return 0;
25581   }
25582   arg1 = *argp1;
25583   {
25584     try {
25585       result = Dali::PropertyBuffer::DownCast(arg1);
25586     } catch (std::out_of_range& e) {
25587       {
25588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25589       };
25590     } catch (std::exception& e) {
25591       {
25592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25593       };
25594     } catch (Dali::DaliException e) {
25595       {
25596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25597       };
25598     } catch (...) {
25599       {
25600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25601       };
25602     }
25603   }
25604
25605   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25606   return jresult;
25607 }
25608
25609
25610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25611   void * jresult ;
25612   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25613   Dali::PropertyBuffer *arg2 = 0 ;
25614   Dali::PropertyBuffer *result = 0 ;
25615
25616   arg1 = (Dali::PropertyBuffer *)jarg1;
25617   arg2 = (Dali::PropertyBuffer *)jarg2;
25618   if (!arg2) {
25619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25620     return 0;
25621   }
25622   {
25623     try {
25624       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25625     } catch (std::out_of_range& e) {
25626       {
25627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25628       };
25629     } catch (std::exception& e) {
25630       {
25631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25632       };
25633     } catch (Dali::DaliException e) {
25634       {
25635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25636       };
25637     } catch (...) {
25638       {
25639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25640       };
25641     }
25642   }
25643
25644   jresult = (void *)result;
25645   return jresult;
25646 }
25647
25648
25649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25650   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25651   void *arg2 = (void *) 0 ;
25652   std::size_t arg3 ;
25653
25654   arg1 = (Dali::PropertyBuffer *)jarg1;
25655   arg2 = jarg2;
25656   arg3 = (std::size_t)jarg3;
25657   {
25658     try {
25659       (arg1)->SetData((void const *)arg2,arg3);
25660     } catch (std::out_of_range& e) {
25661       {
25662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25663       };
25664     } catch (std::exception& e) {
25665       {
25666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25667       };
25668     } catch (Dali::DaliException e) {
25669       {
25670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25671       };
25672     } catch (...) {
25673       {
25674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25675       };
25676     }
25677   }
25678
25679 }
25680
25681
25682 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25683   unsigned long jresult ;
25684   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25685   std::size_t result;
25686
25687   arg1 = (Dali::PropertyBuffer *)jarg1;
25688   {
25689     try {
25690       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25691     } catch (std::out_of_range& e) {
25692       {
25693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25694       };
25695     } catch (std::exception& e) {
25696       {
25697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25698       };
25699     } catch (Dali::DaliException e) {
25700       {
25701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25702       };
25703     } catch (...) {
25704       {
25705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25706       };
25707     }
25708   }
25709
25710   jresult = (unsigned long)result;
25711   return jresult;
25712 }
25713
25714
25715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25716   void * jresult ;
25717   Dali::Geometry result;
25718
25719   {
25720     try {
25721       result = Dali::Geometry::New();
25722     } catch (std::out_of_range& e) {
25723       {
25724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25725       };
25726     } catch (std::exception& e) {
25727       {
25728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25729       };
25730     } catch (Dali::DaliException e) {
25731       {
25732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25733       };
25734     } catch (...) {
25735       {
25736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25737       };
25738     }
25739   }
25740
25741   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25742   return jresult;
25743 }
25744
25745
25746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25747   void * jresult ;
25748   Dali::Geometry *result = 0 ;
25749
25750   {
25751     try {
25752       result = (Dali::Geometry *)new Dali::Geometry();
25753     } catch (std::out_of_range& e) {
25754       {
25755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25756       };
25757     } catch (std::exception& e) {
25758       {
25759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25760       };
25761     } catch (Dali::DaliException e) {
25762       {
25763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25764       };
25765     } catch (...) {
25766       {
25767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25768       };
25769     }
25770   }
25771
25772   jresult = (void *)result;
25773   return jresult;
25774 }
25775
25776
25777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25778   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25779
25780   arg1 = (Dali::Geometry *)jarg1;
25781   {
25782     try {
25783       delete arg1;
25784     } catch (std::out_of_range& e) {
25785       {
25786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25787       };
25788     } catch (std::exception& e) {
25789       {
25790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25791       };
25792     } catch (Dali::DaliException e) {
25793       {
25794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25795       };
25796     } catch (...) {
25797       {
25798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25799       };
25800     }
25801   }
25802
25803 }
25804
25805
25806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25807   void * jresult ;
25808   Dali::Geometry *arg1 = 0 ;
25809   Dali::Geometry *result = 0 ;
25810
25811   arg1 = (Dali::Geometry *)jarg1;
25812   if (!arg1) {
25813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25814     return 0;
25815   }
25816   {
25817     try {
25818       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25819     } catch (std::out_of_range& e) {
25820       {
25821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25822       };
25823     } catch (std::exception& e) {
25824       {
25825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25826       };
25827     } catch (Dali::DaliException e) {
25828       {
25829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25830       };
25831     } catch (...) {
25832       {
25833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25834       };
25835     }
25836   }
25837
25838   jresult = (void *)result;
25839   return jresult;
25840 }
25841
25842
25843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25844   void * jresult ;
25845   Dali::BaseHandle arg1 ;
25846   Dali::BaseHandle *argp1 ;
25847   Dali::Geometry result;
25848
25849   argp1 = (Dali::BaseHandle *)jarg1;
25850   if (!argp1) {
25851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25852     return 0;
25853   }
25854   arg1 = *argp1;
25855   {
25856     try {
25857       result = Dali::Geometry::DownCast(arg1);
25858     } catch (std::out_of_range& e) {
25859       {
25860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25861       };
25862     } catch (std::exception& e) {
25863       {
25864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25865       };
25866     } catch (Dali::DaliException e) {
25867       {
25868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25869       };
25870     } catch (...) {
25871       {
25872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25873       };
25874     }
25875   }
25876
25877   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25878   return jresult;
25879 }
25880
25881
25882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25883   void * jresult ;
25884   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25885   Dali::Geometry *arg2 = 0 ;
25886   Dali::Geometry *result = 0 ;
25887
25888   arg1 = (Dali::Geometry *)jarg1;
25889   arg2 = (Dali::Geometry *)jarg2;
25890   if (!arg2) {
25891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25892     return 0;
25893   }
25894   {
25895     try {
25896       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25897     } catch (std::out_of_range& e) {
25898       {
25899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25900       };
25901     } catch (std::exception& e) {
25902       {
25903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25904       };
25905     } catch (Dali::DaliException e) {
25906       {
25907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25908       };
25909     } catch (...) {
25910       {
25911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25912       };
25913     }
25914   }
25915
25916   jresult = (void *)result;
25917   return jresult;
25918 }
25919
25920
25921 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25922   unsigned long jresult ;
25923   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25924   Dali::PropertyBuffer *arg2 = 0 ;
25925   std::size_t result;
25926
25927   arg1 = (Dali::Geometry *)jarg1;
25928   arg2 = (Dali::PropertyBuffer *)jarg2;
25929   if (!arg2) {
25930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25931     return 0;
25932   }
25933   {
25934     try {
25935       result = (arg1)->AddVertexBuffer(*arg2);
25936     } catch (std::out_of_range& e) {
25937       {
25938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25939       };
25940     } catch (std::exception& e) {
25941       {
25942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25943       };
25944     } catch (Dali::DaliException e) {
25945       {
25946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25947       };
25948     } catch (...) {
25949       {
25950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25951       };
25952     }
25953   }
25954
25955   jresult = (unsigned long)result;
25956   return jresult;
25957 }
25958
25959
25960 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25961   unsigned long jresult ;
25962   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25963   std::size_t result;
25964
25965   arg1 = (Dali::Geometry *)jarg1;
25966   {
25967     try {
25968       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25969     } catch (std::out_of_range& e) {
25970       {
25971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25972       };
25973     } catch (std::exception& e) {
25974       {
25975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25976       };
25977     } catch (Dali::DaliException e) {
25978       {
25979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25980       };
25981     } catch (...) {
25982       {
25983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25984       };
25985     }
25986   }
25987
25988   jresult = (unsigned long)result;
25989   return jresult;
25990 }
25991
25992
25993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25994   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25995   std::size_t arg2 ;
25996
25997   arg1 = (Dali::Geometry *)jarg1;
25998   arg2 = (std::size_t)jarg2;
25999   {
26000     try {
26001       (arg1)->RemoveVertexBuffer(arg2);
26002     } catch (std::out_of_range& e) {
26003       {
26004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26005       };
26006     } catch (std::exception& e) {
26007       {
26008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26009       };
26010     } catch (Dali::DaliException e) {
26011       {
26012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26013       };
26014     } catch (...) {
26015       {
26016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26017       };
26018     }
26019   }
26020
26021 }
26022
26023
26024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26025   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26026   unsigned short *arg2 = (unsigned short *) 0 ;
26027   size_t arg3 ;
26028
26029   arg1 = (Dali::Geometry *)jarg1;
26030   arg2 = jarg2;
26031   arg3 = (size_t)jarg3;
26032   {
26033     try {
26034       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26035     } catch (std::out_of_range& e) {
26036       {
26037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26038       };
26039     } catch (std::exception& e) {
26040       {
26041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26042       };
26043     } catch (Dali::DaliException e) {
26044       {
26045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26046       };
26047     } catch (...) {
26048       {
26049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26050       };
26051     }
26052   }
26053
26054
26055
26056 }
26057
26058
26059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26060   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26061   Dali::Geometry::Type arg2 ;
26062
26063   arg1 = (Dali::Geometry *)jarg1;
26064   arg2 = (Dali::Geometry::Type)jarg2;
26065   {
26066     try {
26067       (arg1)->SetType(arg2);
26068     } catch (std::out_of_range& e) {
26069       {
26070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26071       };
26072     } catch (std::exception& e) {
26073       {
26074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26075       };
26076     } catch (Dali::DaliException e) {
26077       {
26078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26079       };
26080     } catch (...) {
26081       {
26082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26083       };
26084     }
26085   }
26086
26087 }
26088
26089
26090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26091   int jresult ;
26092   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26093   Dali::Geometry::Type result;
26094
26095   arg1 = (Dali::Geometry *)jarg1;
26096   {
26097     try {
26098       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26099     } catch (std::out_of_range& e) {
26100       {
26101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26102       };
26103     } catch (std::exception& e) {
26104       {
26105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26106       };
26107     } catch (Dali::DaliException e) {
26108       {
26109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26110       };
26111     } catch (...) {
26112       {
26113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26114       };
26115     }
26116   }
26117
26118   jresult = (int)result;
26119   return jresult;
26120 }
26121
26122
26123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26124   void * jresult ;
26125   Dali::Shader::Hint *result = 0 ;
26126
26127   {
26128     try {
26129       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26130     } catch (std::out_of_range& e) {
26131       {
26132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26133       };
26134     } catch (std::exception& e) {
26135       {
26136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26137       };
26138     } catch (Dali::DaliException e) {
26139       {
26140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26141       };
26142     } catch (...) {
26143       {
26144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26145       };
26146     }
26147   }
26148
26149   jresult = (void *)result;
26150   return jresult;
26151 }
26152
26153
26154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26155   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26156
26157   arg1 = (Dali::Shader::Hint *)jarg1;
26158   {
26159     try {
26160       delete arg1;
26161     } catch (std::out_of_range& e) {
26162       {
26163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26164       };
26165     } catch (std::exception& e) {
26166       {
26167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26168       };
26169     } catch (Dali::DaliException e) {
26170       {
26171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26172       };
26173     } catch (...) {
26174       {
26175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26176       };
26177     }
26178   }
26179
26180 }
26181
26182
26183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26184   int jresult ;
26185   int result;
26186
26187   result = (int)Dali::Shader::Property::PROGRAM;
26188   jresult = (int)result;
26189   return jresult;
26190 }
26191
26192
26193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26194   void * jresult ;
26195   Dali::Shader::Property *result = 0 ;
26196
26197   {
26198     try {
26199       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26200     } catch (std::out_of_range& e) {
26201       {
26202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26203       };
26204     } catch (std::exception& e) {
26205       {
26206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26207       };
26208     } catch (Dali::DaliException e) {
26209       {
26210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26211       };
26212     } catch (...) {
26213       {
26214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26215       };
26216     }
26217   }
26218
26219   jresult = (void *)result;
26220   return jresult;
26221 }
26222
26223
26224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26225   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26226
26227   arg1 = (Dali::Shader::Property *)jarg1;
26228   {
26229     try {
26230       delete arg1;
26231     } catch (std::out_of_range& e) {
26232       {
26233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26234       };
26235     } catch (std::exception& e) {
26236       {
26237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26238       };
26239     } catch (Dali::DaliException e) {
26240       {
26241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26242       };
26243     } catch (...) {
26244       {
26245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26246       };
26247     }
26248   }
26249
26250 }
26251
26252
26253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26254   void * jresult ;
26255   std::string *arg1 = 0 ;
26256   std::string *arg2 = 0 ;
26257   Dali::Shader::Hint::Value arg3 ;
26258   Dali::Shader result;
26259
26260   if (!jarg1) {
26261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26262     return 0;
26263   }
26264   std::string arg1_str(jarg1);
26265   arg1 = &arg1_str;
26266   if (!jarg2) {
26267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26268     return 0;
26269   }
26270   std::string arg2_str(jarg2);
26271   arg2 = &arg2_str;
26272   arg3 = (Dali::Shader::Hint::Value)jarg3;
26273   {
26274     try {
26275       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26276     } catch (std::out_of_range& e) {
26277       {
26278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26279       };
26280     } catch (std::exception& e) {
26281       {
26282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26283       };
26284     } catch (Dali::DaliException e) {
26285       {
26286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26287       };
26288     } catch (...) {
26289       {
26290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26291       };
26292     }
26293   }
26294
26295   jresult = new Dali::Shader((const Dali::Shader &)result);
26296
26297   //argout typemap for const std::string&
26298
26299
26300   //argout typemap for const std::string&
26301
26302   return jresult;
26303 }
26304
26305
26306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26307   void * jresult ;
26308   std::string *arg1 = 0 ;
26309   std::string *arg2 = 0 ;
26310   Dali::Shader result;
26311
26312   if (!jarg1) {
26313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26314     return 0;
26315   }
26316   std::string arg1_str(jarg1);
26317   arg1 = &arg1_str;
26318   if (!jarg2) {
26319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26320     return 0;
26321   }
26322   std::string arg2_str(jarg2);
26323   arg2 = &arg2_str;
26324   {
26325     try {
26326       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26327     } catch (std::out_of_range& e) {
26328       {
26329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26330       };
26331     } catch (std::exception& e) {
26332       {
26333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26334       };
26335     } catch (Dali::DaliException e) {
26336       {
26337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26338       };
26339     } catch (...) {
26340       {
26341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26342       };
26343     }
26344   }
26345
26346   jresult = new Dali::Shader((const Dali::Shader &)result);
26347
26348   //argout typemap for const std::string&
26349
26350
26351   //argout typemap for const std::string&
26352
26353   return jresult;
26354 }
26355
26356
26357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26358   void * jresult ;
26359   Dali::Shader *result = 0 ;
26360
26361   {
26362     try {
26363       result = (Dali::Shader *)new Dali::Shader();
26364     } catch (std::out_of_range& e) {
26365       {
26366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26367       };
26368     } catch (std::exception& e) {
26369       {
26370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26371       };
26372     } catch (Dali::DaliException e) {
26373       {
26374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26375       };
26376     } catch (...) {
26377       {
26378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26379       };
26380     }
26381   }
26382
26383   jresult = (void *)result;
26384   return jresult;
26385 }
26386
26387
26388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26389   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26390
26391   arg1 = (Dali::Shader *)jarg1;
26392   {
26393     try {
26394       delete arg1;
26395     } catch (std::out_of_range& e) {
26396       {
26397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26398       };
26399     } catch (std::exception& e) {
26400       {
26401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26402       };
26403     } catch (Dali::DaliException e) {
26404       {
26405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26406       };
26407     } catch (...) {
26408       {
26409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26410       };
26411     }
26412   }
26413
26414 }
26415
26416
26417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26418   void * jresult ;
26419   Dali::Shader *arg1 = 0 ;
26420   Dali::Shader *result = 0 ;
26421
26422   arg1 = (Dali::Shader *)jarg1;
26423   if (!arg1) {
26424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26425     return 0;
26426   }
26427   {
26428     try {
26429       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26430     } catch (std::out_of_range& e) {
26431       {
26432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26433       };
26434     } catch (std::exception& e) {
26435       {
26436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26437       };
26438     } catch (Dali::DaliException e) {
26439       {
26440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26441       };
26442     } catch (...) {
26443       {
26444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26445       };
26446     }
26447   }
26448
26449   jresult = (void *)result;
26450   return jresult;
26451 }
26452
26453
26454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26455   void * jresult ;
26456   Dali::BaseHandle arg1 ;
26457   Dali::BaseHandle *argp1 ;
26458   Dali::Shader result;
26459
26460   argp1 = (Dali::BaseHandle *)jarg1;
26461   if (!argp1) {
26462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26463     return 0;
26464   }
26465   arg1 = *argp1;
26466   {
26467     try {
26468       result = Dali::Shader::DownCast(arg1);
26469     } catch (std::out_of_range& e) {
26470       {
26471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26472       };
26473     } catch (std::exception& e) {
26474       {
26475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26476       };
26477     } catch (Dali::DaliException e) {
26478       {
26479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26480       };
26481     } catch (...) {
26482       {
26483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26484       };
26485     }
26486   }
26487
26488   jresult = new Dali::Shader((const Dali::Shader &)result);
26489   return jresult;
26490 }
26491
26492
26493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26494   void * jresult ;
26495   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26496   Dali::Shader *arg2 = 0 ;
26497   Dali::Shader *result = 0 ;
26498
26499   arg1 = (Dali::Shader *)jarg1;
26500   arg2 = (Dali::Shader *)jarg2;
26501   if (!arg2) {
26502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26503     return 0;
26504   }
26505   {
26506     try {
26507       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26508     } catch (std::out_of_range& e) {
26509       {
26510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26511       };
26512     } catch (std::exception& e) {
26513       {
26514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26515       };
26516     } catch (Dali::DaliException e) {
26517       {
26518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26519       };
26520     } catch (...) {
26521       {
26522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26523       };
26524     }
26525   }
26526
26527   jresult = (void *)result;
26528   return jresult;
26529 }
26530
26531
26532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26533   int jresult ;
26534   int result;
26535
26536   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26537   jresult = (int)result;
26538   return jresult;
26539 }
26540
26541
26542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26543   int jresult ;
26544   int result;
26545
26546   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26547   jresult = (int)result;
26548   return jresult;
26549 }
26550
26551
26552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26553   int jresult ;
26554   int result;
26555
26556   result = (int)Dali::Renderer::Property::BLEND_MODE;
26557   jresult = (int)result;
26558   return jresult;
26559 }
26560
26561
26562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26563   int jresult ;
26564   int result;
26565
26566   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26567   jresult = (int)result;
26568   return jresult;
26569 }
26570
26571
26572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26573   int jresult ;
26574   int result;
26575
26576   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26577   jresult = (int)result;
26578   return jresult;
26579 }
26580
26581
26582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26583   int jresult ;
26584   int result;
26585
26586   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26587   jresult = (int)result;
26588   return jresult;
26589 }
26590
26591
26592 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26593   int jresult ;
26594   int result;
26595
26596   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26597   jresult = (int)result;
26598   return jresult;
26599 }
26600
26601
26602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26603   int jresult ;
26604   int result;
26605
26606   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26607   jresult = (int)result;
26608   return jresult;
26609 }
26610
26611
26612 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26613   int jresult ;
26614   int result;
26615
26616   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26617   jresult = (int)result;
26618   return jresult;
26619 }
26620
26621
26622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26623   int jresult ;
26624   int result;
26625
26626   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26627   jresult = (int)result;
26628   return jresult;
26629 }
26630
26631
26632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26633   int jresult ;
26634   int result;
26635
26636   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26637   jresult = (int)result;
26638   return jresult;
26639 }
26640
26641
26642 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26643   int jresult ;
26644   int result;
26645
26646   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26647   jresult = (int)result;
26648   return jresult;
26649 }
26650
26651
26652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26653   int jresult ;
26654   int result;
26655
26656   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26657   jresult = (int)result;
26658   return jresult;
26659 }
26660
26661
26662 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26663   int jresult ;
26664   int result;
26665
26666   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26667   jresult = (int)result;
26668   return jresult;
26669 }
26670
26671
26672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26673   int jresult ;
26674   int result;
26675
26676   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26677   jresult = (int)result;
26678   return jresult;
26679 }
26680
26681
26682 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26683   int jresult ;
26684   int result;
26685
26686   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26687   jresult = (int)result;
26688   return jresult;
26689 }
26690
26691
26692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26693   int jresult ;
26694   int result;
26695
26696   result = (int)Dali::Renderer::Property::RENDER_MODE;
26697   jresult = (int)result;
26698   return jresult;
26699 }
26700
26701
26702 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26703   int jresult ;
26704   int result;
26705
26706   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26707   jresult = (int)result;
26708   return jresult;
26709 }
26710
26711
26712 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26713   int jresult ;
26714   int result;
26715
26716   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26717   jresult = (int)result;
26718   return jresult;
26719 }
26720
26721
26722 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26723   int jresult ;
26724   int result;
26725
26726   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26727   jresult = (int)result;
26728   return jresult;
26729 }
26730
26731
26732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26733   int jresult ;
26734   int result;
26735
26736   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26737   jresult = (int)result;
26738   return jresult;
26739 }
26740
26741
26742 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26743   int jresult ;
26744   int result;
26745
26746   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26747   jresult = (int)result;
26748   return jresult;
26749 }
26750
26751
26752 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26753   int jresult ;
26754   int result;
26755
26756   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26757   jresult = (int)result;
26758   return jresult;
26759 }
26760
26761
26762 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26763   int jresult ;
26764   int result;
26765
26766   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26767   jresult = (int)result;
26768   return jresult;
26769 }
26770
26771
26772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26773   void * jresult ;
26774   Dali::Renderer::Property *result = 0 ;
26775
26776   {
26777     try {
26778       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26779     } catch (std::out_of_range& e) {
26780       {
26781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26782       };
26783     } catch (std::exception& e) {
26784       {
26785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26786       };
26787     } catch (Dali::DaliException e) {
26788       {
26789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26790       };
26791     } catch (...) {
26792       {
26793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26794       };
26795     }
26796   }
26797
26798   jresult = (void *)result;
26799   return jresult;
26800 }
26801
26802
26803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26804   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26805
26806   arg1 = (Dali::Renderer::Property *)jarg1;
26807   {
26808     try {
26809       delete arg1;
26810     } catch (std::out_of_range& e) {
26811       {
26812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26813       };
26814     } catch (std::exception& e) {
26815       {
26816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26817       };
26818     } catch (Dali::DaliException e) {
26819       {
26820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26821       };
26822     } catch (...) {
26823       {
26824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26825       };
26826     }
26827   }
26828
26829 }
26830
26831
26832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26833   void * jresult ;
26834   Dali::Geometry *arg1 = 0 ;
26835   Dali::Shader *arg2 = 0 ;
26836   Dali::Renderer result;
26837
26838   arg1 = (Dali::Geometry *)jarg1;
26839   if (!arg1) {
26840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26841     return 0;
26842   }
26843   arg2 = (Dali::Shader *)jarg2;
26844   if (!arg2) {
26845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26846     return 0;
26847   }
26848   {
26849     try {
26850       result = Dali::Renderer::New(*arg1,*arg2);
26851     } catch (std::out_of_range& e) {
26852       {
26853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26854       };
26855     } catch (std::exception& e) {
26856       {
26857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26858       };
26859     } catch (Dali::DaliException e) {
26860       {
26861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26862       };
26863     } catch (...) {
26864       {
26865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26866       };
26867     }
26868   }
26869
26870   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26871   return jresult;
26872 }
26873
26874
26875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26876   void * jresult ;
26877   Dali::Renderer *result = 0 ;
26878
26879   {
26880     try {
26881       result = (Dali::Renderer *)new Dali::Renderer();
26882     } catch (std::out_of_range& e) {
26883       {
26884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26885       };
26886     } catch (std::exception& e) {
26887       {
26888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26889       };
26890     } catch (Dali::DaliException e) {
26891       {
26892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26893       };
26894     } catch (...) {
26895       {
26896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26897       };
26898     }
26899   }
26900
26901   jresult = (void *)result;
26902   return jresult;
26903 }
26904
26905
26906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26907   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26908
26909   arg1 = (Dali::Renderer *)jarg1;
26910   {
26911     try {
26912       delete arg1;
26913     } catch (std::out_of_range& e) {
26914       {
26915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26916       };
26917     } catch (std::exception& e) {
26918       {
26919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26920       };
26921     } catch (Dali::DaliException e) {
26922       {
26923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26924       };
26925     } catch (...) {
26926       {
26927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26928       };
26929     }
26930   }
26931
26932 }
26933
26934
26935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26936   void * jresult ;
26937   Dali::Renderer *arg1 = 0 ;
26938   Dali::Renderer *result = 0 ;
26939
26940   arg1 = (Dali::Renderer *)jarg1;
26941   if (!arg1) {
26942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26943     return 0;
26944   }
26945   {
26946     try {
26947       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26948     } catch (std::out_of_range& e) {
26949       {
26950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26951       };
26952     } catch (std::exception& e) {
26953       {
26954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26955       };
26956     } catch (Dali::DaliException e) {
26957       {
26958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26959       };
26960     } catch (...) {
26961       {
26962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26963       };
26964     }
26965   }
26966
26967   jresult = (void *)result;
26968   return jresult;
26969 }
26970
26971
26972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26973   void * jresult ;
26974   Dali::BaseHandle arg1 ;
26975   Dali::BaseHandle *argp1 ;
26976   Dali::Renderer result;
26977
26978   argp1 = (Dali::BaseHandle *)jarg1;
26979   if (!argp1) {
26980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26981     return 0;
26982   }
26983   arg1 = *argp1;
26984   {
26985     try {
26986       result = Dali::Renderer::DownCast(arg1);
26987     } catch (std::out_of_range& e) {
26988       {
26989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26990       };
26991     } catch (std::exception& e) {
26992       {
26993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26994       };
26995     } catch (Dali::DaliException e) {
26996       {
26997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26998       };
26999     } catch (...) {
27000       {
27001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27002       };
27003     }
27004   }
27005
27006   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27007   return jresult;
27008 }
27009
27010
27011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27012   void * jresult ;
27013   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27014   Dali::Renderer *arg2 = 0 ;
27015   Dali::Renderer *result = 0 ;
27016
27017   arg1 = (Dali::Renderer *)jarg1;
27018   arg2 = (Dali::Renderer *)jarg2;
27019   if (!arg2) {
27020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27021     return 0;
27022   }
27023   {
27024     try {
27025       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27026     } catch (std::out_of_range& e) {
27027       {
27028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27029       };
27030     } catch (std::exception& e) {
27031       {
27032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27033       };
27034     } catch (Dali::DaliException e) {
27035       {
27036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27037       };
27038     } catch (...) {
27039       {
27040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27041       };
27042     }
27043   }
27044
27045   jresult = (void *)result;
27046   return jresult;
27047 }
27048
27049
27050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27051   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27052   Dali::Geometry *arg2 = 0 ;
27053
27054   arg1 = (Dali::Renderer *)jarg1;
27055   arg2 = (Dali::Geometry *)jarg2;
27056   if (!arg2) {
27057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27058     return ;
27059   }
27060   {
27061     try {
27062       (arg1)->SetGeometry(*arg2);
27063     } catch (std::out_of_range& e) {
27064       {
27065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27066       };
27067     } catch (std::exception& e) {
27068       {
27069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27070       };
27071     } catch (Dali::DaliException e) {
27072       {
27073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27074       };
27075     } catch (...) {
27076       {
27077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27078       };
27079     }
27080   }
27081
27082 }
27083
27084
27085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27086   void * jresult ;
27087   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27088   Dali::Geometry result;
27089
27090   arg1 = (Dali::Renderer *)jarg1;
27091   {
27092     try {
27093       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27094     } catch (std::out_of_range& e) {
27095       {
27096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27097       };
27098     } catch (std::exception& e) {
27099       {
27100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27101       };
27102     } catch (Dali::DaliException e) {
27103       {
27104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27105       };
27106     } catch (...) {
27107       {
27108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27109       };
27110     }
27111   }
27112
27113   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27114   return jresult;
27115 }
27116
27117
27118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27119   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27120   int arg2 ;
27121   int arg3 ;
27122
27123   arg1 = (Dali::Renderer *)jarg1;
27124   arg2 = (int)jarg2;
27125   arg3 = (int)jarg3;
27126   {
27127     try {
27128       (arg1)->SetIndexRange(arg2,arg3);
27129     } catch (std::out_of_range& e) {
27130       {
27131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27132       };
27133     } catch (std::exception& e) {
27134       {
27135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27136       };
27137     } catch (Dali::DaliException e) {
27138       {
27139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27140       };
27141     } catch (...) {
27142       {
27143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27144       };
27145     }
27146   }
27147
27148 }
27149
27150
27151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27152   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27153   Dali::TextureSet *arg2 = 0 ;
27154
27155   arg1 = (Dali::Renderer *)jarg1;
27156   arg2 = (Dali::TextureSet *)jarg2;
27157   if (!arg2) {
27158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27159     return ;
27160   }
27161   {
27162     try {
27163       (arg1)->SetTextures(*arg2);
27164     } catch (std::out_of_range& e) {
27165       {
27166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27167       };
27168     } catch (std::exception& e) {
27169       {
27170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27171       };
27172     } catch (Dali::DaliException e) {
27173       {
27174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27175       };
27176     } catch (...) {
27177       {
27178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27179       };
27180     }
27181   }
27182
27183 }
27184
27185
27186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27187   void * jresult ;
27188   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27189   Dali::TextureSet result;
27190
27191   arg1 = (Dali::Renderer *)jarg1;
27192   {
27193     try {
27194       result = ((Dali::Renderer const *)arg1)->GetTextures();
27195     } catch (std::out_of_range& e) {
27196       {
27197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27198       };
27199     } catch (std::exception& e) {
27200       {
27201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27202       };
27203     } catch (Dali::DaliException e) {
27204       {
27205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27206       };
27207     } catch (...) {
27208       {
27209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27210       };
27211     }
27212   }
27213
27214   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27215   return jresult;
27216 }
27217
27218
27219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27220   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27221   Dali::Shader *arg2 = 0 ;
27222
27223   arg1 = (Dali::Renderer *)jarg1;
27224   arg2 = (Dali::Shader *)jarg2;
27225   if (!arg2) {
27226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27227     return ;
27228   }
27229   {
27230     try {
27231       (arg1)->SetShader(*arg2);
27232     } catch (std::out_of_range& e) {
27233       {
27234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27235       };
27236     } catch (std::exception& e) {
27237       {
27238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27239       };
27240     } catch (Dali::DaliException e) {
27241       {
27242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27243       };
27244     } catch (...) {
27245       {
27246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27247       };
27248     }
27249   }
27250
27251 }
27252
27253
27254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27255   void * jresult ;
27256   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27257   Dali::Shader result;
27258
27259   arg1 = (Dali::Renderer *)jarg1;
27260   {
27261     try {
27262       result = ((Dali::Renderer const *)arg1)->GetShader();
27263     } catch (std::out_of_range& e) {
27264       {
27265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27266       };
27267     } catch (std::exception& e) {
27268       {
27269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27270       };
27271     } catch (Dali::DaliException e) {
27272       {
27273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27274       };
27275     } catch (...) {
27276       {
27277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27278       };
27279     }
27280   }
27281
27282   jresult = new Dali::Shader((const Dali::Shader &)result);
27283   return jresult;
27284 }
27285
27286
27287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27288   void * jresult ;
27289   Dali::FrameBuffer::Attachment *result = 0 ;
27290
27291   {
27292     try {
27293       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27294     } catch (std::out_of_range& e) {
27295       {
27296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27297       };
27298     } catch (std::exception& e) {
27299       {
27300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27301       };
27302     } catch (Dali::DaliException e) {
27303       {
27304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27305       };
27306     } catch (...) {
27307       {
27308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27309       };
27310     }
27311   }
27312
27313   jresult = (void *)result;
27314   return jresult;
27315 }
27316
27317
27318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27319   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27320
27321   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27322   {
27323     try {
27324       delete arg1;
27325     } catch (std::out_of_range& e) {
27326       {
27327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27328       };
27329     } catch (std::exception& e) {
27330       {
27331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27332       };
27333     } catch (Dali::DaliException e) {
27334       {
27335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27336       };
27337     } catch (...) {
27338       {
27339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27340       };
27341     }
27342   }
27343
27344 }
27345
27346
27347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27348   void * jresult ;
27349   unsigned int arg1 ;
27350   unsigned int arg2 ;
27351   unsigned int arg3 ;
27352   Dali::FrameBuffer result;
27353
27354   arg1 = (unsigned int)jarg1;
27355   arg2 = (unsigned int)jarg2;
27356   arg3 = (unsigned int)jarg3;
27357   {
27358     try {
27359       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27360     } catch (std::out_of_range& e) {
27361       {
27362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27363       };
27364     } catch (std::exception& e) {
27365       {
27366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27367       };
27368     } catch (Dali::DaliException e) {
27369       {
27370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27371       };
27372     } catch (...) {
27373       {
27374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27375       };
27376     }
27377   }
27378
27379   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27380   return jresult;
27381 }
27382
27383
27384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27385   void * jresult ;
27386   Dali::FrameBuffer *result = 0 ;
27387
27388   {
27389     try {
27390       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27391     } catch (std::out_of_range& e) {
27392       {
27393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27394       };
27395     } catch (std::exception& e) {
27396       {
27397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27398       };
27399     } catch (Dali::DaliException e) {
27400       {
27401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27402       };
27403     } catch (...) {
27404       {
27405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27406       };
27407     }
27408   }
27409
27410   jresult = (void *)result;
27411   return jresult;
27412 }
27413
27414
27415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27416   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27417
27418   arg1 = (Dali::FrameBuffer *)jarg1;
27419   {
27420     try {
27421       delete arg1;
27422     } catch (std::out_of_range& e) {
27423       {
27424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27425       };
27426     } catch (std::exception& e) {
27427       {
27428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27429       };
27430     } catch (Dali::DaliException e) {
27431       {
27432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27433       };
27434     } catch (...) {
27435       {
27436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27437       };
27438     }
27439   }
27440
27441 }
27442
27443
27444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27445   void * jresult ;
27446   Dali::FrameBuffer *arg1 = 0 ;
27447   Dali::FrameBuffer *result = 0 ;
27448
27449   arg1 = (Dali::FrameBuffer *)jarg1;
27450   if (!arg1) {
27451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27452     return 0;
27453   }
27454   {
27455     try {
27456       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27457     } catch (std::out_of_range& e) {
27458       {
27459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27460       };
27461     } catch (std::exception& e) {
27462       {
27463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27464       };
27465     } catch (Dali::DaliException e) {
27466       {
27467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27468       };
27469     } catch (...) {
27470       {
27471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27472       };
27473     }
27474   }
27475
27476   jresult = (void *)result;
27477   return jresult;
27478 }
27479
27480
27481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27482   void * jresult ;
27483   Dali::BaseHandle arg1 ;
27484   Dali::BaseHandle *argp1 ;
27485   Dali::FrameBuffer result;
27486
27487   argp1 = (Dali::BaseHandle *)jarg1;
27488   if (!argp1) {
27489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27490     return 0;
27491   }
27492   arg1 = *argp1;
27493   {
27494     try {
27495       result = Dali::FrameBuffer::DownCast(arg1);
27496     } catch (std::out_of_range& e) {
27497       {
27498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27499       };
27500     } catch (std::exception& e) {
27501       {
27502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27503       };
27504     } catch (Dali::DaliException e) {
27505       {
27506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27507       };
27508     } catch (...) {
27509       {
27510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27511       };
27512     }
27513   }
27514
27515   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27516   return jresult;
27517 }
27518
27519
27520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27521   void * jresult ;
27522   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27523   Dali::FrameBuffer *arg2 = 0 ;
27524   Dali::FrameBuffer *result = 0 ;
27525
27526   arg1 = (Dali::FrameBuffer *)jarg1;
27527   arg2 = (Dali::FrameBuffer *)jarg2;
27528   if (!arg2) {
27529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27530     return 0;
27531   }
27532   {
27533     try {
27534       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27535     } catch (std::out_of_range& e) {
27536       {
27537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27538       };
27539     } catch (std::exception& e) {
27540       {
27541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27542       };
27543     } catch (Dali::DaliException e) {
27544       {
27545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27546       };
27547     } catch (...) {
27548       {
27549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27550       };
27551     }
27552   }
27553
27554   jresult = (void *)result;
27555   return jresult;
27556 }
27557
27558
27559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27560   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27561   Dali::Texture *arg2 = 0 ;
27562
27563   arg1 = (Dali::FrameBuffer *)jarg1;
27564   arg2 = (Dali::Texture *)jarg2;
27565   if (!arg2) {
27566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27567     return ;
27568   }
27569   {
27570     try {
27571       (arg1)->AttachColorTexture(*arg2);
27572     } catch (std::out_of_range& e) {
27573       {
27574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27575       };
27576     } catch (std::exception& e) {
27577       {
27578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27579       };
27580     } catch (Dali::DaliException e) {
27581       {
27582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27583       };
27584     } catch (...) {
27585       {
27586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27587       };
27588     }
27589   }
27590
27591 }
27592
27593
27594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27595   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27596   Dali::Texture *arg2 = 0 ;
27597   unsigned int arg3 ;
27598   unsigned int arg4 ;
27599
27600   arg1 = (Dali::FrameBuffer *)jarg1;
27601   arg2 = (Dali::Texture *)jarg2;
27602   if (!arg2) {
27603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27604     return ;
27605   }
27606   arg3 = (unsigned int)jarg3;
27607   arg4 = (unsigned int)jarg4;
27608   {
27609     try {
27610       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27611     } catch (std::out_of_range& e) {
27612       {
27613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27614       };
27615     } catch (std::exception& e) {
27616       {
27617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27618       };
27619     } catch (Dali::DaliException e) {
27620       {
27621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27622       };
27623     } catch (...) {
27624       {
27625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27626       };
27627     }
27628   }
27629
27630 }
27631
27632
27633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27634   void * jresult ;
27635   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27636   Dali::Texture result;
27637
27638   arg1 = (Dali::FrameBuffer *)jarg1;
27639   {
27640     try {
27641       result = (arg1)->GetColorTexture();
27642     } catch (std::out_of_range& e) {
27643       {
27644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27645       };
27646     } catch (std::exception& e) {
27647       {
27648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27649       };
27650     } catch (Dali::DaliException e) {
27651       {
27652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27653       };
27654     } catch (...) {
27655       {
27656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27657       };
27658     }
27659   }
27660
27661   jresult = new Dali::Texture((const Dali::Texture &)result);
27662   return jresult;
27663 }
27664
27665
27666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27667   void * jresult ;
27668   Dali::RenderTaskList *result = 0 ;
27669
27670   {
27671     try {
27672       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27673     } catch (std::out_of_range& e) {
27674       {
27675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27676       };
27677     } catch (std::exception& e) {
27678       {
27679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27680       };
27681     } catch (Dali::DaliException e) {
27682       {
27683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27684       };
27685     } catch (...) {
27686       {
27687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27688       };
27689     }
27690   }
27691
27692   jresult = (void *)result;
27693   return jresult;
27694 }
27695
27696
27697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27698   void * jresult ;
27699   Dali::BaseHandle arg1 ;
27700   Dali::BaseHandle *argp1 ;
27701   Dali::RenderTaskList result;
27702
27703   argp1 = (Dali::BaseHandle *)jarg1;
27704   if (!argp1) {
27705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27706     return 0;
27707   }
27708   arg1 = *argp1;
27709   {
27710     try {
27711       result = Dali::RenderTaskList::DownCast(arg1);
27712     } catch (std::out_of_range& e) {
27713       {
27714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27715       };
27716     } catch (std::exception& e) {
27717       {
27718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27719       };
27720     } catch (Dali::DaliException e) {
27721       {
27722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27723       };
27724     } catch (...) {
27725       {
27726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27727       };
27728     }
27729   }
27730
27731   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27732   return jresult;
27733 }
27734
27735
27736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27737   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27738
27739   arg1 = (Dali::RenderTaskList *)jarg1;
27740   {
27741     try {
27742       delete arg1;
27743     } catch (std::out_of_range& e) {
27744       {
27745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27746       };
27747     } catch (std::exception& e) {
27748       {
27749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27750       };
27751     } catch (Dali::DaliException e) {
27752       {
27753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27754       };
27755     } catch (...) {
27756       {
27757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27758       };
27759     }
27760   }
27761
27762 }
27763
27764
27765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27766   void * jresult ;
27767   Dali::RenderTaskList *arg1 = 0 ;
27768   Dali::RenderTaskList *result = 0 ;
27769
27770   arg1 = (Dali::RenderTaskList *)jarg1;
27771   if (!arg1) {
27772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27773     return 0;
27774   }
27775   {
27776     try {
27777       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27778     } catch (std::out_of_range& e) {
27779       {
27780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27781       };
27782     } catch (std::exception& e) {
27783       {
27784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27785       };
27786     } catch (Dali::DaliException e) {
27787       {
27788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27789       };
27790     } catch (...) {
27791       {
27792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27793       };
27794     }
27795   }
27796
27797   jresult = (void *)result;
27798   return jresult;
27799 }
27800
27801
27802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27803   void * jresult ;
27804   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27805   Dali::RenderTaskList *arg2 = 0 ;
27806   Dali::RenderTaskList *result = 0 ;
27807
27808   arg1 = (Dali::RenderTaskList *)jarg1;
27809   arg2 = (Dali::RenderTaskList *)jarg2;
27810   if (!arg2) {
27811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27812     return 0;
27813   }
27814   {
27815     try {
27816       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27817     } catch (std::out_of_range& e) {
27818       {
27819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27820       };
27821     } catch (std::exception& e) {
27822       {
27823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27824       };
27825     } catch (Dali::DaliException e) {
27826       {
27827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27828       };
27829     } catch (...) {
27830       {
27831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27832       };
27833     }
27834   }
27835
27836   jresult = (void *)result;
27837   return jresult;
27838 }
27839
27840
27841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27842   void * jresult ;
27843   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27844   Dali::RenderTask result;
27845
27846   arg1 = (Dali::RenderTaskList *)jarg1;
27847   {
27848     try {
27849       result = (arg1)->CreateTask();
27850     } catch (std::out_of_range& e) {
27851       {
27852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27853       };
27854     } catch (std::exception& e) {
27855       {
27856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27857       };
27858     } catch (Dali::DaliException e) {
27859       {
27860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27861       };
27862     } catch (...) {
27863       {
27864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27865       };
27866     }
27867   }
27868
27869   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27870   return jresult;
27871 }
27872
27873
27874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27875   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27876   Dali::RenderTask arg2 ;
27877   Dali::RenderTask *argp2 ;
27878
27879   arg1 = (Dali::RenderTaskList *)jarg1;
27880   argp2 = (Dali::RenderTask *)jarg2;
27881   if (!argp2) {
27882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27883     return ;
27884   }
27885   arg2 = *argp2;
27886   {
27887     try {
27888       (arg1)->RemoveTask(arg2);
27889     } catch (std::out_of_range& e) {
27890       {
27891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27892       };
27893     } catch (std::exception& e) {
27894       {
27895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27896       };
27897     } catch (Dali::DaliException e) {
27898       {
27899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27900       };
27901     } catch (...) {
27902       {
27903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27904       };
27905     }
27906   }
27907
27908 }
27909
27910
27911 //// ===============================================end part 1 =================
27912
27913 //// ========================= part 2 ===============================
27914
27915 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27916   unsigned int jresult ;
27917   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27918   unsigned int result;
27919
27920   arg1 = (Dali::RenderTaskList *)jarg1;
27921   {
27922     try {
27923       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27924     } catch (std::out_of_range& e) {
27925       {
27926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27927       };
27928     } catch (std::exception& e) {
27929       {
27930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27931       };
27932     } catch (Dali::DaliException e) {
27933       {
27934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27935       };
27936     } catch (...) {
27937       {
27938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27939       };
27940     }
27941   }
27942
27943   jresult = result;
27944   return jresult;
27945 }
27946
27947
27948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27949   void * jresult ;
27950   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27951   unsigned int arg2 ;
27952   Dali::RenderTask result;
27953
27954   arg1 = (Dali::RenderTaskList *)jarg1;
27955   arg2 = (unsigned int)jarg2;
27956   {
27957     try {
27958       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27959     } catch (std::out_of_range& e) {
27960       {
27961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27962       };
27963     } catch (std::exception& e) {
27964       {
27965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27966       };
27967     } catch (Dali::DaliException e) {
27968       {
27969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27970       };
27971     } catch (...) {
27972       {
27973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27974       };
27975     }
27976   }
27977
27978   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27979   return jresult;
27980 }
27981
27982
27983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27984   int jresult ;
27985   int result;
27986
27987   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27988   jresult = (int)result;
27989   return jresult;
27990 }
27991
27992
27993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27994   int jresult ;
27995   int result;
27996
27997   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27998   jresult = (int)result;
27999   return jresult;
28000 }
28001
28002
28003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28004   int jresult ;
28005   int result;
28006
28007   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28008   jresult = (int)result;
28009   return jresult;
28010 }
28011
28012
28013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28014   int jresult ;
28015   int result;
28016
28017   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28018   jresult = (int)result;
28019   return jresult;
28020 }
28021
28022
28023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28024   void * jresult ;
28025   Dali::RenderTask::Property *result = 0 ;
28026
28027   {
28028     try {
28029       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28030     } catch (std::out_of_range& e) {
28031       {
28032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28033       };
28034     } catch (std::exception& e) {
28035       {
28036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28037       };
28038     } catch (Dali::DaliException e) {
28039       {
28040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28041       };
28042     } catch (...) {
28043       {
28044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28045       };
28046     }
28047   }
28048
28049   jresult = (void *)result;
28050   return jresult;
28051 }
28052
28053
28054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28055   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28056
28057   arg1 = (Dali::RenderTask::Property *)jarg1;
28058   {
28059     try {
28060       delete arg1;
28061     } catch (std::out_of_range& e) {
28062       {
28063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28064       };
28065     } catch (std::exception& e) {
28066       {
28067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28068       };
28069     } catch (Dali::DaliException e) {
28070       {
28071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28072       };
28073     } catch (...) {
28074       {
28075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28076       };
28077     }
28078   }
28079
28080 }
28081
28082
28083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28084   void * jresult ;
28085   bool (*result)(Dali::Vector2 &) = 0 ;
28086
28087   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28088   jresult = (void *)result;
28089   return jresult;
28090 }
28091
28092
28093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28094   void * jresult ;
28095   bool (*result)(Dali::Vector2 &) = 0 ;
28096
28097   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28098   jresult = (void *)result;
28099   return jresult;
28100 }
28101
28102
28103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28104   unsigned int jresult ;
28105   bool result;
28106
28107   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28108   jresult = result;
28109   return jresult;
28110 }
28111
28112
28113 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28114   unsigned int jresult ;
28115   bool result;
28116
28117   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28118   jresult = result;
28119   return jresult;
28120 }
28121
28122
28123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28124   void * jresult ;
28125   Dali::Vector4 *result = 0 ;
28126
28127   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28128   jresult = (void *)result;
28129   return jresult;
28130 }
28131
28132
28133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28134   unsigned int jresult ;
28135   bool result;
28136
28137   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28138   jresult = result;
28139   return jresult;
28140 }
28141
28142
28143 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28144   unsigned int jresult ;
28145   bool result;
28146
28147   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28148   jresult = result;
28149   return jresult;
28150 }
28151
28152
28153 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28154   unsigned int jresult ;
28155   unsigned int result;
28156
28157   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28158   jresult = result;
28159   return jresult;
28160 }
28161
28162
28163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28164   void * jresult ;
28165   Dali::RenderTask *result = 0 ;
28166
28167   {
28168     try {
28169       result = (Dali::RenderTask *)new Dali::RenderTask();
28170     } catch (std::out_of_range& e) {
28171       {
28172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28173       };
28174     } catch (std::exception& e) {
28175       {
28176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28177       };
28178     } catch (Dali::DaliException e) {
28179       {
28180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28181       };
28182     } catch (...) {
28183       {
28184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28185       };
28186     }
28187   }
28188
28189   jresult = (void *)result;
28190   return jresult;
28191 }
28192
28193
28194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28195   void * jresult ;
28196   Dali::BaseHandle arg1 ;
28197   Dali::BaseHandle *argp1 ;
28198   Dali::RenderTask result;
28199
28200   argp1 = (Dali::BaseHandle *)jarg1;
28201   if (!argp1) {
28202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28203     return 0;
28204   }
28205   arg1 = *argp1;
28206   {
28207     try {
28208       result = Dali::RenderTask::DownCast(arg1);
28209     } catch (std::out_of_range& e) {
28210       {
28211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28212       };
28213     } catch (std::exception& e) {
28214       {
28215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28216       };
28217     } catch (Dali::DaliException e) {
28218       {
28219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28220       };
28221     } catch (...) {
28222       {
28223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28224       };
28225     }
28226   }
28227
28228   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28229   return jresult;
28230 }
28231
28232
28233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28234   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28235
28236   arg1 = (Dali::RenderTask *)jarg1;
28237   {
28238     try {
28239       delete arg1;
28240     } catch (std::out_of_range& e) {
28241       {
28242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28243       };
28244     } catch (std::exception& e) {
28245       {
28246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28247       };
28248     } catch (Dali::DaliException e) {
28249       {
28250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28251       };
28252     } catch (...) {
28253       {
28254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28255       };
28256     }
28257   }
28258
28259 }
28260
28261
28262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28263   void * jresult ;
28264   Dali::RenderTask *arg1 = 0 ;
28265   Dali::RenderTask *result = 0 ;
28266
28267   arg1 = (Dali::RenderTask *)jarg1;
28268   if (!arg1) {
28269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28270     return 0;
28271   }
28272   {
28273     try {
28274       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28275     } catch (std::out_of_range& e) {
28276       {
28277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28278       };
28279     } catch (std::exception& e) {
28280       {
28281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28282       };
28283     } catch (Dali::DaliException e) {
28284       {
28285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28286       };
28287     } catch (...) {
28288       {
28289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28290       };
28291     }
28292   }
28293
28294   jresult = (void *)result;
28295   return jresult;
28296 }
28297
28298
28299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28300   void * jresult ;
28301   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28302   Dali::RenderTask *arg2 = 0 ;
28303   Dali::RenderTask *result = 0 ;
28304
28305   arg1 = (Dali::RenderTask *)jarg1;
28306   arg2 = (Dali::RenderTask *)jarg2;
28307   if (!arg2) {
28308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28309     return 0;
28310   }
28311   {
28312     try {
28313       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28314     } catch (std::out_of_range& e) {
28315       {
28316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28317       };
28318     } catch (std::exception& e) {
28319       {
28320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28321       };
28322     } catch (Dali::DaliException e) {
28323       {
28324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28325       };
28326     } catch (...) {
28327       {
28328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28329       };
28330     }
28331   }
28332
28333   jresult = (void *)result;
28334   return jresult;
28335 }
28336
28337
28338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28339   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28340   Dali::Actor arg2 ;
28341   Dali::Actor *argp2 ;
28342
28343   arg1 = (Dali::RenderTask *)jarg1;
28344   argp2 = (Dali::Actor *)jarg2;
28345   if (!argp2) {
28346     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28347     return ;
28348   }
28349   arg2 = *argp2;
28350   {
28351     try {
28352       (arg1)->SetSourceActor(arg2);
28353     } catch (std::out_of_range& e) {
28354       {
28355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28356       };
28357     } catch (std::exception& e) {
28358       {
28359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28360       };
28361     } catch (Dali::DaliException e) {
28362       {
28363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28364       };
28365     } catch (...) {
28366       {
28367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28368       };
28369     }
28370   }
28371
28372 }
28373
28374
28375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28376   void * jresult ;
28377   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28378   Dali::Actor result;
28379
28380   arg1 = (Dali::RenderTask *)jarg1;
28381   {
28382     try {
28383       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28384     } catch (std::out_of_range& e) {
28385       {
28386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28387       };
28388     } catch (std::exception& e) {
28389       {
28390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28391       };
28392     } catch (Dali::DaliException e) {
28393       {
28394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28395       };
28396     } catch (...) {
28397       {
28398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28399       };
28400     }
28401   }
28402
28403   jresult = new Dali::Actor((const Dali::Actor &)result);
28404   return jresult;
28405 }
28406
28407
28408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28409   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28410   bool arg2 ;
28411
28412   arg1 = (Dali::RenderTask *)jarg1;
28413   arg2 = jarg2 ? true : false;
28414   {
28415     try {
28416       (arg1)->SetExclusive(arg2);
28417     } catch (std::out_of_range& e) {
28418       {
28419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28420       };
28421     } catch (std::exception& e) {
28422       {
28423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28424       };
28425     } catch (Dali::DaliException e) {
28426       {
28427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28428       };
28429     } catch (...) {
28430       {
28431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28432       };
28433     }
28434   }
28435
28436 }
28437
28438
28439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28440   unsigned int jresult ;
28441   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28442   bool result;
28443
28444   arg1 = (Dali::RenderTask *)jarg1;
28445   {
28446     try {
28447       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28448     } catch (std::out_of_range& e) {
28449       {
28450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28451       };
28452     } catch (std::exception& e) {
28453       {
28454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28455       };
28456     } catch (Dali::DaliException e) {
28457       {
28458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28459       };
28460     } catch (...) {
28461       {
28462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28463       };
28464     }
28465   }
28466
28467   jresult = result;
28468   return jresult;
28469 }
28470
28471
28472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28473   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28474   bool arg2 ;
28475
28476   arg1 = (Dali::RenderTask *)jarg1;
28477   arg2 = jarg2 ? true : false;
28478   {
28479     try {
28480       (arg1)->SetInputEnabled(arg2);
28481     } catch (std::out_of_range& e) {
28482       {
28483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28484       };
28485     } catch (std::exception& e) {
28486       {
28487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28488       };
28489     } catch (Dali::DaliException e) {
28490       {
28491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28492       };
28493     } catch (...) {
28494       {
28495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28496       };
28497     }
28498   }
28499
28500 }
28501
28502
28503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28504   unsigned int jresult ;
28505   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28506   bool result;
28507
28508   arg1 = (Dali::RenderTask *)jarg1;
28509   {
28510     try {
28511       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28512     } catch (std::out_of_range& e) {
28513       {
28514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28515       };
28516     } catch (std::exception& e) {
28517       {
28518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28519       };
28520     } catch (Dali::DaliException e) {
28521       {
28522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28523       };
28524     } catch (...) {
28525       {
28526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28527       };
28528     }
28529   }
28530
28531   jresult = result;
28532   return jresult;
28533 }
28534
28535
28536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28537   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28538   Dali::CameraActor arg2 ;
28539   Dali::CameraActor *argp2 ;
28540
28541   arg1 = (Dali::RenderTask *)jarg1;
28542   argp2 = (Dali::CameraActor *)jarg2;
28543   if (!argp2) {
28544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28545     return ;
28546   }
28547   arg2 = *argp2;
28548   {
28549     try {
28550       (arg1)->SetCameraActor(arg2);
28551     } catch (std::out_of_range& e) {
28552       {
28553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28554       };
28555     } catch (std::exception& e) {
28556       {
28557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28558       };
28559     } catch (Dali::DaliException e) {
28560       {
28561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28562       };
28563     } catch (...) {
28564       {
28565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28566       };
28567     }
28568   }
28569
28570 }
28571
28572
28573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28574   void * jresult ;
28575   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28576   Dali::CameraActor result;
28577
28578   arg1 = (Dali::RenderTask *)jarg1;
28579   {
28580     try {
28581       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28582     } catch (std::out_of_range& e) {
28583       {
28584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28585       };
28586     } catch (std::exception& e) {
28587       {
28588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28589       };
28590     } catch (Dali::DaliException e) {
28591       {
28592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28593       };
28594     } catch (...) {
28595       {
28596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28597       };
28598     }
28599   }
28600
28601   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28602   return jresult;
28603 }
28604
28605
28606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28607   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28608   Dali::FrameBufferImage arg2 ;
28609   Dali::FrameBufferImage *argp2 ;
28610
28611   arg1 = (Dali::RenderTask *)jarg1;
28612   argp2 = (Dali::FrameBufferImage *)jarg2;
28613   if (!argp2) {
28614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28615     return ;
28616   }
28617   arg2 = *argp2;
28618   {
28619     try {
28620       (arg1)->SetTargetFrameBuffer(arg2);
28621     } catch (std::out_of_range& e) {
28622       {
28623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28624       };
28625     } catch (std::exception& e) {
28626       {
28627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28628       };
28629     } catch (Dali::DaliException e) {
28630       {
28631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28632       };
28633     } catch (...) {
28634       {
28635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28636       };
28637     }
28638   }
28639
28640 }
28641
28642
28643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28644   void * jresult ;
28645   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28646   Dali::FrameBufferImage result;
28647
28648   arg1 = (Dali::RenderTask *)jarg1;
28649   {
28650     try {
28651       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28652     } catch (std::out_of_range& e) {
28653       {
28654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28655       };
28656     } catch (std::exception& e) {
28657       {
28658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28659       };
28660     } catch (Dali::DaliException e) {
28661       {
28662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28663       };
28664     } catch (...) {
28665       {
28666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28667       };
28668     }
28669   }
28670
28671   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28672   return jresult;
28673 }
28674
28675
28676 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28677   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28678   Dali::FrameBuffer arg2 ;
28679   Dali::FrameBuffer *argp2 ;
28680
28681   arg1 = (Dali::RenderTask *)jarg1;
28682   argp2 = (Dali::FrameBuffer *)jarg2;
28683   if (!argp2) {
28684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28685     return ;
28686   }
28687   arg2 = *argp2;
28688   {
28689     try {
28690       (arg1)->SetFrameBuffer(arg2);
28691     } catch (std::out_of_range& e) {
28692       {
28693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28694       };
28695     } catch (std::exception& e) {
28696       {
28697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28698       };
28699     } catch (Dali::DaliException e) {
28700       {
28701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28702       };
28703     } catch (...) {
28704       {
28705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28706       };
28707     }
28708   }
28709
28710 }
28711
28712
28713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28714   void * jresult ;
28715   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28716   Dali::FrameBuffer result;
28717
28718   arg1 = (Dali::RenderTask *)jarg1;
28719   {
28720     try {
28721       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28722     } catch (std::out_of_range& e) {
28723       {
28724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28725       };
28726     } catch (std::exception& e) {
28727       {
28728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28729       };
28730     } catch (Dali::DaliException e) {
28731       {
28732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28733       };
28734     } catch (...) {
28735       {
28736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28737       };
28738     }
28739   }
28740
28741   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28742   return jresult;
28743 }
28744
28745
28746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28747   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28748   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28749
28750   arg1 = (Dali::RenderTask *)jarg1;
28751   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28752   {
28753     try {
28754       (arg1)->SetScreenToFrameBufferFunction(arg2);
28755     } catch (std::out_of_range& e) {
28756       {
28757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28758       };
28759     } catch (std::exception& e) {
28760       {
28761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28762       };
28763     } catch (Dali::DaliException e) {
28764       {
28765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28766       };
28767     } catch (...) {
28768       {
28769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28770       };
28771     }
28772   }
28773
28774 }
28775
28776
28777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28778   void * jresult ;
28779   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28780   Dali::RenderTask::ScreenToFrameBufferFunction result;
28781
28782   arg1 = (Dali::RenderTask *)jarg1;
28783   {
28784     try {
28785       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28786     } catch (std::out_of_range& e) {
28787       {
28788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28789       };
28790     } catch (std::exception& e) {
28791       {
28792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28793       };
28794     } catch (Dali::DaliException e) {
28795       {
28796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28797       };
28798     } catch (...) {
28799       {
28800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28801       };
28802     }
28803   }
28804
28805   jresult = (void *)result;
28806   return jresult;
28807 }
28808
28809
28810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28811   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28812   Dali::Actor arg2 ;
28813   Dali::Actor *argp2 ;
28814
28815   arg1 = (Dali::RenderTask *)jarg1;
28816   argp2 = (Dali::Actor *)jarg2;
28817   if (!argp2) {
28818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28819     return ;
28820   }
28821   arg2 = *argp2;
28822   {
28823     try {
28824       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28825     } catch (std::out_of_range& e) {
28826       {
28827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28828       };
28829     } catch (std::exception& e) {
28830       {
28831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28832       };
28833     } catch (Dali::DaliException e) {
28834       {
28835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28836       };
28837     } catch (...) {
28838       {
28839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28840       };
28841     }
28842   }
28843
28844 }
28845
28846
28847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28848   void * jresult ;
28849   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28850   Dali::Actor result;
28851
28852   arg1 = (Dali::RenderTask *)jarg1;
28853   {
28854     try {
28855       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28856     } catch (std::out_of_range& e) {
28857       {
28858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28859       };
28860     } catch (std::exception& e) {
28861       {
28862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28863       };
28864     } catch (Dali::DaliException e) {
28865       {
28866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28867       };
28868     } catch (...) {
28869       {
28870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28871       };
28872     }
28873   }
28874
28875   jresult = new Dali::Actor((const Dali::Actor &)result);
28876   return jresult;
28877 }
28878
28879
28880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28881   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28882   Dali::Vector2 arg2 ;
28883   Dali::Vector2 *argp2 ;
28884
28885   arg1 = (Dali::RenderTask *)jarg1;
28886   argp2 = (Dali::Vector2 *)jarg2;
28887   if (!argp2) {
28888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28889     return ;
28890   }
28891   arg2 = *argp2;
28892   {
28893     try {
28894       (arg1)->SetViewportPosition(arg2);
28895     } catch (std::out_of_range& e) {
28896       {
28897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28898       };
28899     } catch (std::exception& e) {
28900       {
28901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28902       };
28903     } catch (Dali::DaliException e) {
28904       {
28905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28906       };
28907     } catch (...) {
28908       {
28909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28910       };
28911     }
28912   }
28913
28914 }
28915
28916
28917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28918   void * jresult ;
28919   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28920   Dali::Vector2 result;
28921
28922   arg1 = (Dali::RenderTask *)jarg1;
28923   {
28924     try {
28925       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28926     } catch (std::out_of_range& e) {
28927       {
28928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28929       };
28930     } catch (std::exception& e) {
28931       {
28932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28933       };
28934     } catch (Dali::DaliException e) {
28935       {
28936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28937       };
28938     } catch (...) {
28939       {
28940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28941       };
28942     }
28943   }
28944
28945   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28946   return jresult;
28947 }
28948
28949
28950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28951   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28952   Dali::Vector2 arg2 ;
28953   Dali::Vector2 *argp2 ;
28954
28955   arg1 = (Dali::RenderTask *)jarg1;
28956   argp2 = (Dali::Vector2 *)jarg2;
28957   if (!argp2) {
28958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28959     return ;
28960   }
28961   arg2 = *argp2;
28962   {
28963     try {
28964       (arg1)->SetViewportSize(arg2);
28965     } catch (std::out_of_range& e) {
28966       {
28967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28968       };
28969     } catch (std::exception& e) {
28970       {
28971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28972       };
28973     } catch (Dali::DaliException e) {
28974       {
28975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28976       };
28977     } catch (...) {
28978       {
28979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28980       };
28981     }
28982   }
28983
28984 }
28985
28986
28987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28988   void * jresult ;
28989   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28990   Dali::Vector2 result;
28991
28992   arg1 = (Dali::RenderTask *)jarg1;
28993   {
28994     try {
28995       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28996     } catch (std::out_of_range& e) {
28997       {
28998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28999       };
29000     } catch (std::exception& e) {
29001       {
29002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29003       };
29004     } catch (Dali::DaliException e) {
29005       {
29006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29007       };
29008     } catch (...) {
29009       {
29010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29011       };
29012     }
29013   }
29014
29015   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29016   return jresult;
29017 }
29018
29019
29020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29021   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29022   Dali::Viewport arg2 ;
29023   Dali::Viewport *argp2 ;
29024
29025   arg1 = (Dali::RenderTask *)jarg1;
29026   argp2 = (Dali::Viewport *)jarg2;
29027   if (!argp2) {
29028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29029     return ;
29030   }
29031   arg2 = *argp2;
29032   {
29033     try {
29034       (arg1)->SetViewport(arg2);
29035     } catch (std::out_of_range& e) {
29036       {
29037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29038       };
29039     } catch (std::exception& e) {
29040       {
29041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29042       };
29043     } catch (Dali::DaliException e) {
29044       {
29045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29046       };
29047     } catch (...) {
29048       {
29049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29050       };
29051     }
29052   }
29053
29054 }
29055
29056
29057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29058   void * jresult ;
29059   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29060   Dali::Viewport result;
29061
29062   arg1 = (Dali::RenderTask *)jarg1;
29063   {
29064     try {
29065       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29066     } catch (std::out_of_range& e) {
29067       {
29068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29069       };
29070     } catch (std::exception& e) {
29071       {
29072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29073       };
29074     } catch (Dali::DaliException e) {
29075       {
29076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29077       };
29078     } catch (...) {
29079       {
29080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29081       };
29082     }
29083   }
29084
29085   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29086   return jresult;
29087 }
29088
29089
29090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29091   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29092   Dali::Vector4 *arg2 = 0 ;
29093
29094   arg1 = (Dali::RenderTask *)jarg1;
29095   arg2 = (Dali::Vector4 *)jarg2;
29096   if (!arg2) {
29097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29098     return ;
29099   }
29100   {
29101     try {
29102       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29103     } catch (std::out_of_range& e) {
29104       {
29105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29106       };
29107     } catch (std::exception& e) {
29108       {
29109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29110       };
29111     } catch (Dali::DaliException e) {
29112       {
29113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29114       };
29115     } catch (...) {
29116       {
29117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29118       };
29119     }
29120   }
29121
29122 }
29123
29124
29125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29126   void * jresult ;
29127   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29128   Dali::Vector4 result;
29129
29130   arg1 = (Dali::RenderTask *)jarg1;
29131   {
29132     try {
29133       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29134     } catch (std::out_of_range& e) {
29135       {
29136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29137       };
29138     } catch (std::exception& e) {
29139       {
29140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29141       };
29142     } catch (Dali::DaliException e) {
29143       {
29144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29145       };
29146     } catch (...) {
29147       {
29148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29149       };
29150     }
29151   }
29152
29153   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29154   return jresult;
29155 }
29156
29157
29158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29159   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29160   bool arg2 ;
29161
29162   arg1 = (Dali::RenderTask *)jarg1;
29163   arg2 = jarg2 ? true : false;
29164   {
29165     try {
29166       (arg1)->SetClearEnabled(arg2);
29167     } catch (std::out_of_range& e) {
29168       {
29169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29170       };
29171     } catch (std::exception& e) {
29172       {
29173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29174       };
29175     } catch (Dali::DaliException e) {
29176       {
29177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29178       };
29179     } catch (...) {
29180       {
29181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29182       };
29183     }
29184   }
29185
29186 }
29187
29188
29189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29190   unsigned int jresult ;
29191   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29192   bool result;
29193
29194   arg1 = (Dali::RenderTask *)jarg1;
29195   {
29196     try {
29197       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29198     } catch (std::out_of_range& e) {
29199       {
29200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29201       };
29202     } catch (std::exception& e) {
29203       {
29204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29205       };
29206     } catch (Dali::DaliException e) {
29207       {
29208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29209       };
29210     } catch (...) {
29211       {
29212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29213       };
29214     }
29215   }
29216
29217   jresult = result;
29218   return jresult;
29219 }
29220
29221
29222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29223   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29224   bool arg2 ;
29225
29226   arg1 = (Dali::RenderTask *)jarg1;
29227   arg2 = jarg2 ? true : false;
29228   {
29229     try {
29230       (arg1)->SetCullMode(arg2);
29231     } catch (std::out_of_range& e) {
29232       {
29233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29234       };
29235     } catch (std::exception& e) {
29236       {
29237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29238       };
29239     } catch (Dali::DaliException e) {
29240       {
29241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29242       };
29243     } catch (...) {
29244       {
29245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29246       };
29247     }
29248   }
29249
29250 }
29251
29252
29253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29254   unsigned int jresult ;
29255   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29256   bool result;
29257
29258   arg1 = (Dali::RenderTask *)jarg1;
29259   {
29260     try {
29261       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29262     } catch (std::out_of_range& e) {
29263       {
29264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29265       };
29266     } catch (std::exception& e) {
29267       {
29268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29269       };
29270     } catch (Dali::DaliException e) {
29271       {
29272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29273       };
29274     } catch (...) {
29275       {
29276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29277       };
29278     }
29279   }
29280
29281   jresult = result;
29282   return jresult;
29283 }
29284
29285
29286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29287   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29288   unsigned int arg2 ;
29289
29290   arg1 = (Dali::RenderTask *)jarg1;
29291   arg2 = (unsigned int)jarg2;
29292   {
29293     try {
29294       (arg1)->SetRefreshRate(arg2);
29295     } catch (std::out_of_range& e) {
29296       {
29297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29298       };
29299     } catch (std::exception& e) {
29300       {
29301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29302       };
29303     } catch (Dali::DaliException e) {
29304       {
29305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29306       };
29307     } catch (...) {
29308       {
29309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29310       };
29311     }
29312   }
29313
29314 }
29315
29316
29317 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29318   unsigned int jresult ;
29319   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29320   unsigned int result;
29321
29322   arg1 = (Dali::RenderTask *)jarg1;
29323   {
29324     try {
29325       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29326     } catch (std::out_of_range& e) {
29327       {
29328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29329       };
29330     } catch (std::exception& e) {
29331       {
29332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29333       };
29334     } catch (Dali::DaliException e) {
29335       {
29336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29337       };
29338     } catch (...) {
29339       {
29340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29341       };
29342     }
29343   }
29344
29345   jresult = result;
29346   return jresult;
29347 }
29348
29349
29350 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29351   unsigned int jresult ;
29352   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29353   Dali::Vector3 *arg2 = 0 ;
29354   float *arg3 = 0 ;
29355   float *arg4 = 0 ;
29356   bool result;
29357
29358   arg1 = (Dali::RenderTask *)jarg1;
29359   arg2 = (Dali::Vector3 *)jarg2;
29360   if (!arg2) {
29361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29362     return 0;
29363   }
29364   arg3 = (float *)jarg3;
29365   arg4 = (float *)jarg4;
29366   {
29367     try {
29368       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29369     } catch (std::out_of_range& e) {
29370       {
29371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29372       };
29373     } catch (std::exception& e) {
29374       {
29375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29376       };
29377     } catch (Dali::DaliException e) {
29378       {
29379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29380       };
29381     } catch (...) {
29382       {
29383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29384       };
29385     }
29386   }
29387
29388   jresult = result;
29389   return jresult;
29390 }
29391
29392
29393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29394   unsigned int jresult ;
29395   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29396   Dali::Actor arg2 ;
29397   float arg3 ;
29398   float arg4 ;
29399   float *arg5 = 0 ;
29400   float *arg6 = 0 ;
29401   Dali::Actor *argp2 ;
29402   bool result;
29403
29404   arg1 = (Dali::RenderTask *)jarg1;
29405   argp2 = (Dali::Actor *)jarg2;
29406   if (!argp2) {
29407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29408     return 0;
29409   }
29410   arg2 = *argp2;
29411   arg3 = (float)jarg3;
29412   arg4 = (float)jarg4;
29413   arg5 = (float *)jarg5;
29414   arg6 = (float *)jarg6;
29415   {
29416     try {
29417       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29418     } catch (std::out_of_range& e) {
29419       {
29420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29421       };
29422     } catch (std::exception& e) {
29423       {
29424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29425       };
29426     } catch (Dali::DaliException e) {
29427       {
29428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29429       };
29430     } catch (...) {
29431       {
29432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29433       };
29434     }
29435   }
29436
29437   jresult = result;
29438   return jresult;
29439 }
29440
29441
29442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29443   void * jresult ;
29444   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29445   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29446
29447   arg1 = (Dali::RenderTask *)jarg1;
29448   {
29449     try {
29450       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29451     } catch (std::out_of_range& e) {
29452       {
29453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29454       };
29455     } catch (std::exception& e) {
29456       {
29457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29458       };
29459     } catch (Dali::DaliException e) {
29460       {
29461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29462       };
29463     } catch (...) {
29464       {
29465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29466       };
29467     }
29468   }
29469
29470   jresult = (void *)result;
29471   return jresult;
29472 }
29473
29474
29475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29476   void * jresult ;
29477   int arg1 ;
29478   Dali::TouchPoint::State arg2 ;
29479   float arg3 ;
29480   float arg4 ;
29481   Dali::TouchPoint *result = 0 ;
29482
29483   arg1 = (int)jarg1;
29484   arg2 = (Dali::TouchPoint::State)jarg2;
29485   arg3 = (float)jarg3;
29486   arg4 = (float)jarg4;
29487   {
29488     try {
29489       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29490     } catch (std::out_of_range& e) {
29491       {
29492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29493       };
29494     } catch (std::exception& e) {
29495       {
29496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29497       };
29498     } catch (Dali::DaliException e) {
29499       {
29500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29501       };
29502     } catch (...) {
29503       {
29504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29505       };
29506     }
29507   }
29508
29509   jresult = (void *)result;
29510   return jresult;
29511 }
29512
29513
29514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29515   void * jresult ;
29516   int arg1 ;
29517   Dali::TouchPoint::State arg2 ;
29518   float arg3 ;
29519   float arg4 ;
29520   float arg5 ;
29521   float arg6 ;
29522   Dali::TouchPoint *result = 0 ;
29523
29524   arg1 = (int)jarg1;
29525   arg2 = (Dali::TouchPoint::State)jarg2;
29526   arg3 = (float)jarg3;
29527   arg4 = (float)jarg4;
29528   arg5 = (float)jarg5;
29529   arg6 = (float)jarg6;
29530   {
29531     try {
29532       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29533     } catch (std::out_of_range& e) {
29534       {
29535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29536       };
29537     } catch (std::exception& e) {
29538       {
29539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29540       };
29541     } catch (Dali::DaliException e) {
29542       {
29543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29544       };
29545     } catch (...) {
29546       {
29547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29548       };
29549     }
29550   }
29551
29552   jresult = (void *)result;
29553   return jresult;
29554 }
29555
29556
29557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29558   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29559
29560   arg1 = (Dali::TouchPoint *)jarg1;
29561   {
29562     try {
29563       delete arg1;
29564     } catch (std::out_of_range& e) {
29565       {
29566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29567       };
29568     } catch (std::exception& e) {
29569       {
29570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29571       };
29572     } catch (Dali::DaliException e) {
29573       {
29574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29575       };
29576     } catch (...) {
29577       {
29578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29579       };
29580     }
29581   }
29582
29583 }
29584
29585
29586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29587   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29588   int arg2 ;
29589
29590   arg1 = (Dali::TouchPoint *)jarg1;
29591   arg2 = (int)jarg2;
29592   if (arg1) (arg1)->deviceId = arg2;
29593 }
29594
29595
29596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29597   int jresult ;
29598   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29599   int result;
29600
29601   arg1 = (Dali::TouchPoint *)jarg1;
29602   result = (int) ((arg1)->deviceId);
29603   jresult = result;
29604   return jresult;
29605 }
29606
29607
29608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29609   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29610   Dali::TouchPoint::State arg2 ;
29611
29612   arg1 = (Dali::TouchPoint *)jarg1;
29613   arg2 = (Dali::TouchPoint::State)jarg2;
29614   if (arg1) (arg1)->state = arg2;
29615 }
29616
29617
29618 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29619   int jresult ;
29620   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29621   Dali::TouchPoint::State result;
29622
29623   arg1 = (Dali::TouchPoint *)jarg1;
29624   result = (Dali::TouchPoint::State) ((arg1)->state);
29625   jresult = (int)result;
29626   return jresult;
29627 }
29628
29629
29630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29631   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29632   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29633
29634   arg1 = (Dali::TouchPoint *)jarg1;
29635   arg2 = (Dali::Actor *)jarg2;
29636   if (arg1) (arg1)->hitActor = *arg2;
29637 }
29638
29639
29640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29641   void * jresult ;
29642   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29643   Dali::Actor *result = 0 ;
29644
29645   arg1 = (Dali::TouchPoint *)jarg1;
29646   result = (Dali::Actor *)& ((arg1)->hitActor);
29647   jresult = (void *)result;
29648   return jresult;
29649 }
29650
29651
29652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29653   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29654   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29655
29656   arg1 = (Dali::TouchPoint *)jarg1;
29657   arg2 = (Dali::Vector2 *)jarg2;
29658   if (arg1) (arg1)->local = *arg2;
29659 }
29660
29661
29662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29663   void * jresult ;
29664   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29665   Dali::Vector2 *result = 0 ;
29666
29667   arg1 = (Dali::TouchPoint *)jarg1;
29668   result = (Dali::Vector2 *)& ((arg1)->local);
29669   jresult = (void *)result;
29670   return jresult;
29671 }
29672
29673
29674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29675   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29676   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29677
29678   arg1 = (Dali::TouchPoint *)jarg1;
29679   arg2 = (Dali::Vector2 *)jarg2;
29680   if (arg1) (arg1)->screen = *arg2;
29681 }
29682
29683
29684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29685   void * jresult ;
29686   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29687   Dali::Vector2 *result = 0 ;
29688
29689   arg1 = (Dali::TouchPoint *)jarg1;
29690   result = (Dali::Vector2 *)& ((arg1)->screen);
29691   jresult = (void *)result;
29692   return jresult;
29693 }
29694
29695
29696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29697   void * jresult ;
29698   Dali::TouchData *result = 0 ;
29699
29700   {
29701     try {
29702       result = (Dali::TouchData *)new Dali::TouchData();
29703     } catch (std::out_of_range& e) {
29704       {
29705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29706       };
29707     } catch (std::exception& e) {
29708       {
29709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29710       };
29711     } catch (Dali::DaliException e) {
29712       {
29713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29714       };
29715     } catch (...) {
29716       {
29717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29718       };
29719     }
29720   }
29721
29722   jresult = (void *)result;
29723   return jresult;
29724 }
29725
29726
29727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29728   void * jresult ;
29729   Dali::TouchData *arg1 = 0 ;
29730   Dali::TouchData *result = 0 ;
29731
29732   arg1 = (Dali::TouchData *)jarg1;
29733   if (!arg1) {
29734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29735     return 0;
29736   }
29737   {
29738     try {
29739       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29740     } catch (std::out_of_range& e) {
29741       {
29742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29743       };
29744     } catch (std::exception& e) {
29745       {
29746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29747       };
29748     } catch (Dali::DaliException e) {
29749       {
29750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29751       };
29752     } catch (...) {
29753       {
29754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29755       };
29756     }
29757   }
29758
29759   jresult = (void *)result;
29760   return jresult;
29761 }
29762
29763
29764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29765   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29766
29767   arg1 = (Dali::TouchData *)jarg1;
29768   {
29769     try {
29770       delete arg1;
29771     } catch (std::out_of_range& e) {
29772       {
29773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29774       };
29775     } catch (std::exception& e) {
29776       {
29777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29778       };
29779     } catch (Dali::DaliException e) {
29780       {
29781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29782       };
29783     } catch (...) {
29784       {
29785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29786       };
29787     }
29788   }
29789
29790 }
29791
29792
29793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29794   void * jresult ;
29795   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29796   Dali::TouchData *arg2 = 0 ;
29797   Dali::TouchData *result = 0 ;
29798
29799   arg1 = (Dali::TouchData *)jarg1;
29800   arg2 = (Dali::TouchData *)jarg2;
29801   if (!arg2) {
29802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29803     return 0;
29804   }
29805   {
29806     try {
29807       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29808     } catch (std::out_of_range& e) {
29809       {
29810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29811       };
29812     } catch (std::exception& e) {
29813       {
29814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29815       };
29816     } catch (Dali::DaliException e) {
29817       {
29818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29819       };
29820     } catch (...) {
29821       {
29822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29823       };
29824     }
29825   }
29826
29827   jresult = (void *)result;
29828   return jresult;
29829 }
29830
29831
29832 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29833   unsigned long jresult ;
29834   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29835   unsigned long result;
29836
29837   arg1 = (Dali::TouchData *)jarg1;
29838   {
29839     try {
29840       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29841     } catch (std::out_of_range& e) {
29842       {
29843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29844       };
29845     } catch (std::exception& e) {
29846       {
29847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29848       };
29849     } catch (Dali::DaliException e) {
29850       {
29851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29852       };
29853     } catch (...) {
29854       {
29855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29856       };
29857     }
29858   }
29859
29860   jresult = (unsigned long)result;
29861   return jresult;
29862 }
29863
29864
29865 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29866   unsigned long jresult ;
29867   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29868   std::size_t result;
29869
29870   arg1 = (Dali::TouchData *)jarg1;
29871   {
29872     try {
29873       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29874     } catch (std::out_of_range& e) {
29875       {
29876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29877       };
29878     } catch (std::exception& e) {
29879       {
29880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29881       };
29882     } catch (Dali::DaliException e) {
29883       {
29884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29885       };
29886     } catch (...) {
29887       {
29888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29889       };
29890     }
29891   }
29892
29893   jresult = (unsigned long)result;
29894   return jresult;
29895 }
29896
29897
29898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29899   int jresult ;
29900   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29901   std::size_t arg2 ;
29902   int32_t result;
29903
29904   arg1 = (Dali::TouchData *)jarg1;
29905   arg2 = (std::size_t)jarg2;
29906   {
29907     try {
29908       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29909     } catch (std::out_of_range& e) {
29910       {
29911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29912       };
29913     } catch (std::exception& e) {
29914       {
29915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29916       };
29917     } catch (Dali::DaliException e) {
29918       {
29919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29920       };
29921     } catch (...) {
29922       {
29923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29924       };
29925     }
29926   }
29927
29928   jresult = result;
29929   return jresult;
29930 }
29931
29932
29933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29934   int jresult ;
29935   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29936   std::size_t arg2 ;
29937   Dali::PointState::Type result;
29938
29939   arg1 = (Dali::TouchData *)jarg1;
29940   arg2 = (std::size_t)jarg2;
29941   {
29942     try {
29943       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29944     } catch (std::out_of_range& e) {
29945       {
29946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29947       };
29948     } catch (std::exception& e) {
29949       {
29950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29951       };
29952     } catch (Dali::DaliException e) {
29953       {
29954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29955       };
29956     } catch (...) {
29957       {
29958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29959       };
29960     }
29961   }
29962
29963   jresult = (int)result;
29964   return jresult;
29965 }
29966
29967
29968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29969   void * jresult ;
29970   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29971   std::size_t arg2 ;
29972   Dali::Actor result;
29973
29974   arg1 = (Dali::TouchData *)jarg1;
29975   arg2 = (std::size_t)jarg2;
29976   {
29977     try {
29978       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29979     } catch (std::out_of_range& e) {
29980       {
29981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29982       };
29983     } catch (std::exception& e) {
29984       {
29985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29986       };
29987     } catch (Dali::DaliException e) {
29988       {
29989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29990       };
29991     } catch (...) {
29992       {
29993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29994       };
29995     }
29996   }
29997
29998   jresult = new Dali::Actor((const Dali::Actor &)result);
29999   return jresult;
30000 }
30001
30002
30003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30004   void * jresult ;
30005   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30006   std::size_t arg2 ;
30007   Dali::Vector2 *result = 0 ;
30008
30009   arg1 = (Dali::TouchData *)jarg1;
30010   arg2 = (std::size_t)jarg2;
30011   {
30012     try {
30013       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30014     } catch (std::out_of_range& e) {
30015       {
30016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30017       };
30018     } catch (std::exception& e) {
30019       {
30020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30021       };
30022     } catch (Dali::DaliException e) {
30023       {
30024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30025       };
30026     } catch (...) {
30027       {
30028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30029       };
30030     }
30031   }
30032
30033   jresult = (void *)result;
30034   return jresult;
30035 }
30036
30037
30038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30039   void * jresult ;
30040   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30041   std::size_t arg2 ;
30042   Dali::Vector2 *result = 0 ;
30043
30044   arg1 = (Dali::TouchData *)jarg1;
30045   arg2 = (std::size_t)jarg2;
30046   {
30047     try {
30048       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30049     } catch (std::out_of_range& e) {
30050       {
30051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30052       };
30053     } catch (std::exception& e) {
30054       {
30055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30056       };
30057     } catch (Dali::DaliException e) {
30058       {
30059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30060       };
30061     } catch (...) {
30062       {
30063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30064       };
30065     }
30066   }
30067
30068   jresult = (void *)result;
30069   return jresult;
30070 }
30071
30072
30073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30074   float jresult ;
30075   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30076   std::size_t arg2 ;
30077   float result;
30078
30079   arg1 = (Dali::TouchData *)jarg1;
30080   arg2 = (std::size_t)jarg2;
30081   {
30082     try {
30083       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30084     } catch (std::out_of_range& e) {
30085       {
30086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30087       };
30088     } catch (std::exception& e) {
30089       {
30090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30091       };
30092     } catch (Dali::DaliException e) {
30093       {
30094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30095       };
30096     } catch (...) {
30097       {
30098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30099       };
30100     }
30101   }
30102
30103   jresult = result;
30104   return jresult;
30105 }
30106
30107
30108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30109   void * jresult ;
30110   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30111   std::size_t arg2 ;
30112   Dali::Vector2 *result = 0 ;
30113
30114   arg1 = (Dali::TouchData *)jarg1;
30115   arg2 = (std::size_t)jarg2;
30116   {
30117     try {
30118       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30119     } catch (std::out_of_range& e) {
30120       {
30121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30122       };
30123     } catch (std::exception& e) {
30124       {
30125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30126       };
30127     } catch (Dali::DaliException e) {
30128       {
30129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30130       };
30131     } catch (...) {
30132       {
30133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30134       };
30135     }
30136   }
30137
30138   jresult = (void *)result;
30139   return jresult;
30140 }
30141
30142
30143 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30144   float jresult ;
30145   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30146   std::size_t arg2 ;
30147   float result;
30148
30149   arg1 = (Dali::TouchData *)jarg1;
30150   arg2 = (std::size_t)jarg2;
30151   {
30152     try {
30153       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30154     } catch (std::out_of_range& e) {
30155       {
30156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30157       };
30158     } catch (std::exception& e) {
30159       {
30160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30161       };
30162     } catch (Dali::DaliException e) {
30163       {
30164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30165       };
30166     } catch (...) {
30167       {
30168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30169       };
30170     }
30171   }
30172
30173   jresult = result;
30174   return jresult;
30175 }
30176
30177
30178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30179   void * jresult ;
30180   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30181   std::size_t arg2 ;
30182   Dali::Degree result;
30183
30184   arg1 = (Dali::TouchData *)jarg1;
30185   arg2 = (std::size_t)jarg2;
30186   {
30187     try {
30188       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30189     } catch (std::out_of_range& e) {
30190       {
30191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30192       };
30193     } catch (std::exception& e) {
30194       {
30195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30196       };
30197     } catch (Dali::DaliException e) {
30198       {
30199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30200       };
30201     } catch (...) {
30202       {
30203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30204       };
30205     }
30206   }
30207
30208   jresult = new Dali::Degree((const Dali::Degree &)result);
30209   return jresult;
30210 }
30211
30212
30213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30214   int jresult ;
30215   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30216   std::size_t arg2 ;
30217   Dali::MouseButton::Type result;
30218
30219   arg1 = (Dali::TouchData *)jarg1;
30220   arg2 = (std::size_t)jarg2;
30221   {
30222     try {
30223       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30224     } catch (std::out_of_range& e) {
30225       {
30226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30227       };
30228     } catch (std::exception& e) {
30229       {
30230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30231       };
30232     } catch (Dali::DaliException e) {
30233       {
30234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30235       };
30236     } catch (...) {
30237       {
30238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30239       };
30240     }
30241   }
30242
30243   jresult = static_cast< int >(result);
30244   return jresult;
30245 }
30246
30247
30248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30249   void * jresult ;
30250   Dali::GestureDetector *result = 0 ;
30251
30252   {
30253     try {
30254       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30255     } catch (std::out_of_range& e) {
30256       {
30257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30258       };
30259     } catch (std::exception& e) {
30260       {
30261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30262       };
30263     } catch (Dali::DaliException e) {
30264       {
30265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30266       };
30267     } catch (...) {
30268       {
30269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30270       };
30271     }
30272   }
30273
30274   jresult = (void *)result;
30275   return jresult;
30276 }
30277
30278
30279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30280   void * jresult ;
30281   Dali::BaseHandle arg1 ;
30282   Dali::BaseHandle *argp1 ;
30283   Dali::GestureDetector result;
30284
30285   argp1 = (Dali::BaseHandle *)jarg1;
30286   if (!argp1) {
30287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30288     return 0;
30289   }
30290   arg1 = *argp1;
30291   {
30292     try {
30293       result = Dali::GestureDetector::DownCast(arg1);
30294     } catch (std::out_of_range& e) {
30295       {
30296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30297       };
30298     } catch (std::exception& e) {
30299       {
30300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30301       };
30302     } catch (Dali::DaliException e) {
30303       {
30304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30305       };
30306     } catch (...) {
30307       {
30308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30309       };
30310     }
30311   }
30312
30313   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30314   return jresult;
30315 }
30316
30317
30318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30319   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30320
30321   arg1 = (Dali::GestureDetector *)jarg1;
30322   {
30323     try {
30324       delete arg1;
30325     } catch (std::out_of_range& e) {
30326       {
30327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30328       };
30329     } catch (std::exception& e) {
30330       {
30331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30332       };
30333     } catch (Dali::DaliException e) {
30334       {
30335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30336       };
30337     } catch (...) {
30338       {
30339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30340       };
30341     }
30342   }
30343
30344 }
30345
30346
30347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30348   void * jresult ;
30349   Dali::GestureDetector *arg1 = 0 ;
30350   Dali::GestureDetector *result = 0 ;
30351
30352   arg1 = (Dali::GestureDetector *)jarg1;
30353   if (!arg1) {
30354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30355     return 0;
30356   }
30357   {
30358     try {
30359       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30360     } catch (std::out_of_range& e) {
30361       {
30362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30363       };
30364     } catch (std::exception& e) {
30365       {
30366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30367       };
30368     } catch (Dali::DaliException e) {
30369       {
30370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30371       };
30372     } catch (...) {
30373       {
30374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30375       };
30376     }
30377   }
30378
30379   jresult = (void *)result;
30380   return jresult;
30381 }
30382
30383
30384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30385   void * jresult ;
30386   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30387   Dali::GestureDetector *arg2 = 0 ;
30388   Dali::GestureDetector *result = 0 ;
30389
30390   arg1 = (Dali::GestureDetector *)jarg1;
30391   arg2 = (Dali::GestureDetector *)jarg2;
30392   if (!arg2) {
30393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30394     return 0;
30395   }
30396   {
30397     try {
30398       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30399     } catch (std::out_of_range& e) {
30400       {
30401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30402       };
30403     } catch (std::exception& e) {
30404       {
30405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30406       };
30407     } catch (Dali::DaliException e) {
30408       {
30409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30410       };
30411     } catch (...) {
30412       {
30413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30414       };
30415     }
30416   }
30417
30418   jresult = (void *)result;
30419   return jresult;
30420 }
30421
30422
30423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30424   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30425   Dali::Actor arg2 ;
30426   Dali::Actor *argp2 ;
30427
30428   arg1 = (Dali::GestureDetector *)jarg1;
30429   argp2 = (Dali::Actor *)jarg2;
30430   if (!argp2) {
30431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30432     return ;
30433   }
30434   arg2 = *argp2;
30435   {
30436     try {
30437       (arg1)->Attach(arg2);
30438     } catch (std::out_of_range& e) {
30439       {
30440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30441       };
30442     } catch (std::exception& e) {
30443       {
30444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30445       };
30446     } catch (Dali::DaliException e) {
30447       {
30448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30449       };
30450     } catch (...) {
30451       {
30452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30453       };
30454     }
30455   }
30456
30457 }
30458
30459
30460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30461   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30462   Dali::Actor arg2 ;
30463   Dali::Actor *argp2 ;
30464
30465   arg1 = (Dali::GestureDetector *)jarg1;
30466   argp2 = (Dali::Actor *)jarg2;
30467   if (!argp2) {
30468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30469     return ;
30470   }
30471   arg2 = *argp2;
30472   {
30473     try {
30474       (arg1)->Detach(arg2);
30475     } catch (std::out_of_range& e) {
30476       {
30477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30478       };
30479     } catch (std::exception& e) {
30480       {
30481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30482       };
30483     } catch (Dali::DaliException e) {
30484       {
30485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30486       };
30487     } catch (...) {
30488       {
30489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30490       };
30491     }
30492   }
30493
30494 }
30495
30496
30497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30498   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30499
30500   arg1 = (Dali::GestureDetector *)jarg1;
30501   {
30502     try {
30503       (arg1)->DetachAll();
30504     } catch (std::out_of_range& e) {
30505       {
30506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30507       };
30508     } catch (std::exception& e) {
30509       {
30510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30511       };
30512     } catch (Dali::DaliException e) {
30513       {
30514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30515       };
30516     } catch (...) {
30517       {
30518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30519       };
30520     }
30521   }
30522
30523 }
30524
30525
30526 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30527   unsigned long jresult ;
30528   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30529   size_t result;
30530
30531   arg1 = (Dali::GestureDetector *)jarg1;
30532   {
30533     try {
30534       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30535     } catch (std::out_of_range& e) {
30536       {
30537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30538       };
30539     } catch (std::exception& e) {
30540       {
30541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30542       };
30543     } catch (Dali::DaliException e) {
30544       {
30545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30546       };
30547     } catch (...) {
30548       {
30549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30550       };
30551     }
30552   }
30553
30554   jresult = (unsigned long)result;
30555   return jresult;
30556 }
30557
30558
30559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30560   void * jresult ;
30561   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30562   size_t arg2 ;
30563   Dali::Actor result;
30564
30565   arg1 = (Dali::GestureDetector *)jarg1;
30566   arg2 = (size_t)jarg2;
30567   {
30568     try {
30569       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30570     } catch (std::out_of_range& e) {
30571       {
30572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30573       };
30574     } catch (std::exception& e) {
30575       {
30576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30577       };
30578     } catch (Dali::DaliException e) {
30579       {
30580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30581       };
30582     } catch (...) {
30583       {
30584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30585       };
30586     }
30587   }
30588
30589   jresult = new Dali::Actor((const Dali::Actor &)result);
30590   return jresult;
30591 }
30592
30593
30594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30595   void * jresult ;
30596   Dali::Gesture *arg1 = 0 ;
30597   Dali::Gesture *result = 0 ;
30598
30599   arg1 = (Dali::Gesture *)jarg1;
30600   if (!arg1) {
30601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30602     return 0;
30603   }
30604   {
30605     try {
30606       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30607     } catch (std::out_of_range& e) {
30608       {
30609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30610       };
30611     } catch (std::exception& e) {
30612       {
30613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30614       };
30615     } catch (Dali::DaliException e) {
30616       {
30617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30618       };
30619     } catch (...) {
30620       {
30621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30622       };
30623     }
30624   }
30625
30626   jresult = (void *)result;
30627   return jresult;
30628 }
30629
30630
30631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30632   void * jresult ;
30633   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30634   Dali::Gesture *arg2 = 0 ;
30635   Dali::Gesture *result = 0 ;
30636
30637   arg1 = (Dali::Gesture *)jarg1;
30638   arg2 = (Dali::Gesture *)jarg2;
30639   if (!arg2) {
30640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30641     return 0;
30642   }
30643   {
30644     try {
30645       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30646     } catch (std::out_of_range& e) {
30647       {
30648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30649       };
30650     } catch (std::exception& e) {
30651       {
30652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30653       };
30654     } catch (Dali::DaliException e) {
30655       {
30656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30657       };
30658     } catch (...) {
30659       {
30660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30661       };
30662     }
30663   }
30664
30665   jresult = (void *)result;
30666   return jresult;
30667 }
30668
30669
30670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30671   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30672
30673   arg1 = (Dali::Gesture *)jarg1;
30674   {
30675     try {
30676       delete arg1;
30677     } catch (std::out_of_range& e) {
30678       {
30679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30680       };
30681     } catch (std::exception& e) {
30682       {
30683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30684       };
30685     } catch (Dali::DaliException e) {
30686       {
30687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30688       };
30689     } catch (...) {
30690       {
30691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30692       };
30693     }
30694   }
30695
30696 }
30697
30698
30699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30700   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30701   Dali::Gesture::Type arg2 ;
30702
30703   arg1 = (Dali::Gesture *)jarg1;
30704   arg2 = (Dali::Gesture::Type)jarg2;
30705   if (arg1) (arg1)->type = arg2;
30706 }
30707
30708
30709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30710   int jresult ;
30711   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30712   Dali::Gesture::Type result;
30713
30714   arg1 = (Dali::Gesture *)jarg1;
30715   result = (Dali::Gesture::Type) ((arg1)->type);
30716   jresult = (int)result;
30717   return jresult;
30718 }
30719
30720
30721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30722   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30723   Dali::Gesture::State arg2 ;
30724
30725   arg1 = (Dali::Gesture *)jarg1;
30726   arg2 = (Dali::Gesture::State)jarg2;
30727   if (arg1) (arg1)->state = arg2;
30728 }
30729
30730
30731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30732   int jresult ;
30733   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30734   Dali::Gesture::State result;
30735
30736   arg1 = (Dali::Gesture *)jarg1;
30737   result = (Dali::Gesture::State) ((arg1)->state);
30738   jresult = (int)result;
30739   return jresult;
30740 }
30741
30742
30743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30744   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30745   unsigned int arg2 ;
30746
30747   arg1 = (Dali::Gesture *)jarg1;
30748   arg2 = (unsigned int)jarg2;
30749   if (arg1) (arg1)->time = arg2;
30750 }
30751
30752
30753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30754   unsigned int jresult ;
30755   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30756   unsigned int result;
30757
30758   arg1 = (Dali::Gesture *)jarg1;
30759   result = (unsigned int) ((arg1)->time);
30760   jresult = result;
30761   return jresult;
30762 }
30763
30764
30765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30766   void * jresult ;
30767   Dali::HoverEvent *result = 0 ;
30768
30769   {
30770     try {
30771       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30772     } catch (std::out_of_range& e) {
30773       {
30774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30775       };
30776     } catch (std::exception& e) {
30777       {
30778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30779       };
30780     } catch (Dali::DaliException e) {
30781       {
30782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30783       };
30784     } catch (...) {
30785       {
30786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30787       };
30788     }
30789   }
30790
30791   jresult = (void *)result;
30792   return jresult;
30793 }
30794
30795
30796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30797   void * jresult ;
30798   unsigned long arg1 ;
30799   Dali::HoverEvent *result = 0 ;
30800
30801   arg1 = (unsigned long)jarg1;
30802   {
30803     try {
30804       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30805     } catch (std::out_of_range& e) {
30806       {
30807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30808       };
30809     } catch (std::exception& e) {
30810       {
30811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30812       };
30813     } catch (Dali::DaliException e) {
30814       {
30815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30816       };
30817     } catch (...) {
30818       {
30819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30820       };
30821     }
30822   }
30823
30824   jresult = (void *)result;
30825   return jresult;
30826 }
30827
30828
30829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30830   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30831
30832   arg1 = (Dali::HoverEvent *)jarg1;
30833   {
30834     try {
30835       delete arg1;
30836     } catch (std::out_of_range& e) {
30837       {
30838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30839       };
30840     } catch (std::exception& e) {
30841       {
30842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30843       };
30844     } catch (Dali::DaliException e) {
30845       {
30846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30847       };
30848     } catch (...) {
30849       {
30850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30851       };
30852     }
30853   }
30854
30855 }
30856
30857
30858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30859   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30860   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30861
30862   arg1 = (Dali::HoverEvent *)jarg1;
30863   arg2 = (Dali::TouchPointContainer *)jarg2;
30864   if (arg1) (arg1)->points = *arg2;
30865 }
30866
30867
30868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30869   void * jresult ;
30870   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30871   Dali::TouchPointContainer *result = 0 ;
30872
30873   arg1 = (Dali::HoverEvent *)jarg1;
30874   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30875   jresult = (void *)result;
30876   return jresult;
30877 }
30878
30879
30880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30881   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30882   unsigned long arg2 ;
30883
30884   arg1 = (Dali::HoverEvent *)jarg1;
30885   arg2 = (unsigned long)jarg2;
30886   if (arg1) (arg1)->time = arg2;
30887 }
30888
30889
30890 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30891   unsigned long jresult ;
30892   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30893   unsigned long result;
30894
30895   arg1 = (Dali::HoverEvent *)jarg1;
30896   result = (unsigned long) ((arg1)->time);
30897   jresult = (unsigned long)result;
30898   return jresult;
30899 }
30900
30901
30902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30903   unsigned int jresult ;
30904   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30905   unsigned int result;
30906
30907   arg1 = (Dali::HoverEvent *)jarg1;
30908   {
30909     try {
30910       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30911     } catch (std::out_of_range& e) {
30912       {
30913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30914       };
30915     } catch (std::exception& e) {
30916       {
30917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30918       };
30919     } catch (Dali::DaliException e) {
30920       {
30921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30922       };
30923     } catch (...) {
30924       {
30925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30926       };
30927     }
30928   }
30929
30930   jresult = result;
30931   return jresult;
30932 }
30933
30934
30935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30936   void * jresult ;
30937   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30938   unsigned int arg2 ;
30939   Dali::TouchPoint *result = 0 ;
30940
30941   arg1 = (Dali::HoverEvent *)jarg1;
30942   arg2 = (unsigned int)jarg2;
30943   {
30944     try {
30945       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30946     } catch (std::out_of_range& e) {
30947       {
30948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30949       };
30950     } catch (std::exception& e) {
30951       {
30952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30953       };
30954     } catch (Dali::DaliException e) {
30955       {
30956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30957       };
30958     } catch (...) {
30959       {
30960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30961       };
30962     }
30963   }
30964
30965   jresult = (void *)result;
30966   return jresult;
30967 }
30968
30969
30970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30971   void * jresult ;
30972   Dali::KeyEvent *result = 0 ;
30973
30974   {
30975     try {
30976       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30977     } catch (std::out_of_range& e) {
30978       {
30979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30980       };
30981     } catch (std::exception& e) {
30982       {
30983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30984       };
30985     } catch (Dali::DaliException e) {
30986       {
30987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30988       };
30989     } catch (...) {
30990       {
30991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30992       };
30993     }
30994   }
30995
30996   jresult = (void *)result;
30997   return jresult;
30998 }
30999
31000
31001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31002   void * jresult ;
31003   std::string *arg1 = 0 ;
31004   std::string *arg2 = 0 ;
31005   int arg3 ;
31006   int arg4 ;
31007   unsigned long arg5 ;
31008   Dali::KeyEvent::State *arg6 = 0 ;
31009   Dali::KeyEvent::State temp6 ;
31010   Dali::KeyEvent *result = 0 ;
31011
31012   if (!jarg1) {
31013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31014     return 0;
31015   }
31016   std::string arg1_str(jarg1);
31017   arg1 = &arg1_str;
31018   if (!jarg2) {
31019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31020     return 0;
31021   }
31022   std::string arg2_str(jarg2);
31023   arg2 = &arg2_str;
31024   arg3 = (int)jarg3;
31025   arg4 = (int)jarg4;
31026   arg5 = (unsigned long)jarg5;
31027   temp6 = (Dali::KeyEvent::State)jarg6;
31028   arg6 = &temp6;
31029   {
31030     try {
31031       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31032     } catch (std::out_of_range& e) {
31033       {
31034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31035       };
31036     } catch (std::exception& e) {
31037       {
31038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31039       };
31040     } catch (Dali::DaliException e) {
31041       {
31042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31043       };
31044     } catch (...) {
31045       {
31046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31047       };
31048     }
31049   }
31050
31051   jresult = (void *)result;
31052
31053   //argout typemap for const std::string&
31054
31055
31056   //argout typemap for const std::string&
31057
31058   return jresult;
31059 }
31060
31061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31062   void * jresult ;
31063   Dali::KeyEvent *arg1 = 0 ;
31064   Dali::KeyEvent *result = 0 ;
31065
31066   arg1 = (Dali::KeyEvent *)jarg1;
31067   if (!arg1) {
31068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31069     return 0;
31070   }
31071   {
31072     try {
31073       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31074     } catch (std::out_of_range& e) {
31075       {
31076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31077       };
31078     } catch (std::exception& e) {
31079       {
31080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31081       };
31082     } catch (Dali::DaliException e) {
31083       {
31084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31085       };
31086     } catch (...) {
31087       {
31088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31089       };
31090     }
31091   }
31092
31093   jresult = (void *)result;
31094   return jresult;
31095 }
31096
31097
31098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31099   void * jresult ;
31100   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31101   Dali::KeyEvent *arg2 = 0 ;
31102   Dali::KeyEvent *result = 0 ;
31103
31104   arg1 = (Dali::KeyEvent *)jarg1;
31105   arg2 = (Dali::KeyEvent *)jarg2;
31106   if (!arg2) {
31107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31108     return 0;
31109   }
31110   {
31111     try {
31112       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31113     } catch (std::out_of_range& e) {
31114       {
31115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31116       };
31117     } catch (std::exception& e) {
31118       {
31119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31120       };
31121     } catch (Dali::DaliException e) {
31122       {
31123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31124       };
31125     } catch (...) {
31126       {
31127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31128       };
31129     }
31130   }
31131
31132   jresult = (void *)result;
31133   return jresult;
31134 }
31135
31136
31137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31138   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31139
31140   arg1 = (Dali::KeyEvent *)jarg1;
31141   {
31142     try {
31143       delete arg1;
31144     } catch (std::out_of_range& e) {
31145       {
31146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31147       };
31148     } catch (std::exception& e) {
31149       {
31150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31151       };
31152     } catch (Dali::DaliException e) {
31153       {
31154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31155       };
31156     } catch (...) {
31157       {
31158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31159       };
31160     }
31161   }
31162
31163 }
31164
31165
31166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31167   unsigned int jresult ;
31168   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31169   bool result;
31170
31171   arg1 = (Dali::KeyEvent *)jarg1;
31172   {
31173     try {
31174       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31175     } catch (std::out_of_range& e) {
31176       {
31177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31178       };
31179     } catch (std::exception& e) {
31180       {
31181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31182       };
31183     } catch (Dali::DaliException e) {
31184       {
31185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31186       };
31187     } catch (...) {
31188       {
31189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31190       };
31191     }
31192   }
31193
31194   jresult = result;
31195   return jresult;
31196 }
31197
31198
31199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31200   unsigned int jresult ;
31201   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31202   bool result;
31203
31204   arg1 = (Dali::KeyEvent *)jarg1;
31205   {
31206     try {
31207       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31208     } catch (std::out_of_range& e) {
31209       {
31210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31211       };
31212     } catch (std::exception& e) {
31213       {
31214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31215       };
31216     } catch (Dali::DaliException e) {
31217       {
31218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31219       };
31220     } catch (...) {
31221       {
31222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31223       };
31224     }
31225   }
31226
31227   jresult = result;
31228   return jresult;
31229 }
31230
31231
31232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31233   unsigned int jresult ;
31234   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31235   bool result;
31236
31237   arg1 = (Dali::KeyEvent *)jarg1;
31238   {
31239     try {
31240       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31241     } catch (std::out_of_range& e) {
31242       {
31243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31244       };
31245     } catch (std::exception& e) {
31246       {
31247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31248       };
31249     } catch (Dali::DaliException e) {
31250       {
31251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31252       };
31253     } catch (...) {
31254       {
31255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31256       };
31257     }
31258   }
31259
31260   jresult = result;
31261   return jresult;
31262 }
31263
31264
31265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31266   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31267   std::string *arg2 = 0 ;
31268
31269   arg1 = (Dali::KeyEvent *)jarg1;
31270   if (!jarg2) {
31271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31272     return ;
31273   }
31274   std::string arg2_str(jarg2);
31275   arg2 = &arg2_str;
31276   if (arg1) (arg1)->keyPressedName = *arg2;
31277
31278   //argout typemap for const std::string&
31279
31280 }
31281
31282
31283 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31284   char * jresult ;
31285
31286   if( jarg1 == NULL )
31287   {
31288     jresult = SWIG_csharp_string_callback( "" );
31289   }
31290   else
31291   {
31292     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31293     std::string *result = 0;
31294
31295     arg1 = ( Dali::KeyEvent * )jarg1;
31296     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31297     jresult = SWIG_csharp_string_callback( result->c_str() );
31298   }
31299
31300   return jresult;
31301 }
31302
31303
31304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31305   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31306   std::string *arg2 = 0 ;
31307
31308   arg1 = (Dali::KeyEvent *)jarg1;
31309   if (!jarg2) {
31310     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31311     return ;
31312   }
31313   std::string arg2_str(jarg2);
31314   arg2 = &arg2_str;
31315   if (arg1) (arg1)->keyPressed = *arg2;
31316
31317   //argout typemap for const std::string&
31318
31319 }
31320
31321
31322 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31323   char * jresult ;
31324   if( NULL == jarg1 )
31325   {
31326     jresult = SWIG_csharp_string_callback( "" );
31327   }
31328   else
31329   {
31330     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31331     std::string *result = 0;
31332
31333     arg1 = ( Dali::KeyEvent * )jarg1;
31334     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31335     jresult = SWIG_csharp_string_callback( result->c_str() );
31336   }
31337   return jresult;
31338 }
31339
31340
31341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31342   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31343   int arg2 ;
31344
31345   arg1 = (Dali::KeyEvent *)jarg1;
31346   arg2 = (int)jarg2;
31347   if (arg1) (arg1)->keyCode = arg2;
31348 }
31349
31350
31351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31352   int jresult ;
31353   if( NULL == jarg1 )
31354   {
31355     jresult = -1;
31356   }
31357   else
31358   {
31359     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31360     int result;
31361
31362     arg1 = ( Dali::KeyEvent * )jarg1;
31363     result = (int)( ( arg1 )->keyCode );
31364     jresult = result;
31365   }
31366   return jresult;
31367 }
31368
31369
31370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31371   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31372   int arg2 ;
31373
31374   arg1 = (Dali::KeyEvent *)jarg1;
31375   arg2 = (int)jarg2;
31376   if (arg1) (arg1)->keyModifier = arg2;
31377 }
31378
31379
31380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31381   int jresult ;
31382   if( jarg1 == NULL )
31383   {
31384     jresult = -1;
31385   }
31386   else
31387   {
31388     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31389     int result;
31390
31391     arg1 = ( Dali::KeyEvent * )jarg1;
31392     result = (int)( ( arg1 )->keyModifier );
31393     jresult = result;
31394   }
31395   return jresult;
31396 }
31397
31398
31399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31400   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31401   unsigned long arg2 ;
31402
31403   arg1 = (Dali::KeyEvent *)jarg1;
31404   arg2 = (unsigned long)jarg2;
31405   if (arg1) (arg1)->time = arg2;
31406 }
31407
31408
31409 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31410   unsigned long jresult ;
31411   if( jarg1 == NULL )
31412   {
31413     jresult = 0;
31414   }
31415   else
31416   {
31417     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31418     unsigned long result;
31419
31420     arg1 = ( Dali::KeyEvent * )jarg1;
31421     result = (unsigned long)( ( arg1 )->time );
31422     jresult = (unsigned long)result;
31423   }
31424   return jresult;
31425 }
31426
31427
31428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31429   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31430   Dali::KeyEvent::State arg2 ;
31431
31432   arg1 = (Dali::KeyEvent *)jarg1;
31433   arg2 = (Dali::KeyEvent::State)jarg2;
31434   if (arg1) (arg1)->state = arg2;
31435 }
31436
31437
31438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31439   int jresult ;
31440   if( jarg1 == NULL )
31441   {
31442     jresult = -1;
31443   }
31444   else
31445   {
31446     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31447     Dali::KeyEvent::State result;
31448
31449     arg1 = ( Dali::KeyEvent * )jarg1;
31450     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31451     jresult = (int)result;
31452   }
31453   return jresult;
31454 }
31455
31456 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31457   char * jresult ;
31458   std::string result;
31459   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31460
31461   arg1 = (Dali::KeyEvent *)jarg1;
31462   if (!arg1) {
31463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31464     return 0;
31465   }
31466   {
31467     try {
31468       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31469     } catch (std::out_of_range& e) {
31470       {
31471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31472       };
31473     } catch (std::exception& e) {
31474       {
31475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31476       };
31477     } catch (Dali::DaliException e) {
31478       {
31479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31480       };
31481     } catch (...) {
31482       {
31483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31484       };
31485     }
31486
31487   }
31488
31489   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31490   return jresult;
31491 }
31492
31493
31494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31495   void * jresult ;
31496   Dali::LongPressGestureDetector *result = 0 ;
31497
31498   {
31499     try {
31500       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31501     } catch (std::out_of_range& e) {
31502       {
31503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31504       };
31505     } catch (std::exception& e) {
31506       {
31507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31508       };
31509     } catch (Dali::DaliException e) {
31510       {
31511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31512       };
31513     } catch (...) {
31514       {
31515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31516       };
31517     }
31518   }
31519
31520   jresult = (void *)result;
31521   return jresult;
31522 }
31523
31524
31525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31526   void * jresult ;
31527   Dali::LongPressGestureDetector result;
31528
31529   {
31530     try {
31531       result = Dali::LongPressGestureDetector::New();
31532     } catch (std::out_of_range& e) {
31533       {
31534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31535       };
31536     } catch (std::exception& e) {
31537       {
31538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31539       };
31540     } catch (Dali::DaliException e) {
31541       {
31542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31543       };
31544     } catch (...) {
31545       {
31546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31547       };
31548     }
31549   }
31550
31551   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31552   return jresult;
31553 }
31554
31555
31556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31557   void * jresult ;
31558   unsigned int arg1 ;
31559   Dali::LongPressGestureDetector result;
31560
31561   arg1 = (unsigned int)jarg1;
31562   {
31563     try {
31564       result = Dali::LongPressGestureDetector::New(arg1);
31565     } catch (std::out_of_range& e) {
31566       {
31567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31568       };
31569     } catch (std::exception& e) {
31570       {
31571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31572       };
31573     } catch (Dali::DaliException e) {
31574       {
31575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31576       };
31577     } catch (...) {
31578       {
31579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31580       };
31581     }
31582   }
31583
31584   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31585   return jresult;
31586 }
31587
31588
31589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31590   void * jresult ;
31591   unsigned int arg1 ;
31592   unsigned int arg2 ;
31593   Dali::LongPressGestureDetector result;
31594
31595   arg1 = (unsigned int)jarg1;
31596   arg2 = (unsigned int)jarg2;
31597   {
31598     try {
31599       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31600     } catch (std::out_of_range& e) {
31601       {
31602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31603       };
31604     } catch (std::exception& e) {
31605       {
31606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31607       };
31608     } catch (Dali::DaliException e) {
31609       {
31610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31611       };
31612     } catch (...) {
31613       {
31614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31615       };
31616     }
31617   }
31618
31619   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31620   return jresult;
31621 }
31622
31623
31624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31625   void * jresult ;
31626   Dali::BaseHandle arg1 ;
31627   Dali::BaseHandle *argp1 ;
31628   Dali::LongPressGestureDetector result;
31629
31630   argp1 = (Dali::BaseHandle *)jarg1;
31631   if (!argp1) {
31632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31633     return 0;
31634   }
31635   arg1 = *argp1;
31636   {
31637     try {
31638       result = Dali::LongPressGestureDetector::DownCast(arg1);
31639     } catch (std::out_of_range& e) {
31640       {
31641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31642       };
31643     } catch (std::exception& e) {
31644       {
31645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31646       };
31647     } catch (Dali::DaliException e) {
31648       {
31649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31650       };
31651     } catch (...) {
31652       {
31653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31654       };
31655     }
31656   }
31657
31658   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31659   return jresult;
31660 }
31661
31662
31663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31664   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31665
31666   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31667   {
31668     try {
31669       delete arg1;
31670     } catch (std::out_of_range& e) {
31671       {
31672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31673       };
31674     } catch (std::exception& e) {
31675       {
31676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31677       };
31678     } catch (Dali::DaliException e) {
31679       {
31680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31681       };
31682     } catch (...) {
31683       {
31684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31685       };
31686     }
31687   }
31688
31689 }
31690
31691
31692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31693   void * jresult ;
31694   Dali::LongPressGestureDetector *arg1 = 0 ;
31695   Dali::LongPressGestureDetector *result = 0 ;
31696
31697   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31698   if (!arg1) {
31699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31700     return 0;
31701   }
31702   {
31703     try {
31704       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31705     } catch (std::out_of_range& e) {
31706       {
31707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31708       };
31709     } catch (std::exception& e) {
31710       {
31711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31712       };
31713     } catch (Dali::DaliException e) {
31714       {
31715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31716       };
31717     } catch (...) {
31718       {
31719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31720       };
31721     }
31722   }
31723
31724   jresult = (void *)result;
31725   return jresult;
31726 }
31727
31728
31729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31730   void * jresult ;
31731   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31732   Dali::LongPressGestureDetector *arg2 = 0 ;
31733   Dali::LongPressGestureDetector *result = 0 ;
31734
31735   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31736   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31737   if (!arg2) {
31738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31739     return 0;
31740   }
31741   {
31742     try {
31743       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31744     } catch (std::out_of_range& e) {
31745       {
31746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31747       };
31748     } catch (std::exception& e) {
31749       {
31750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31751       };
31752     } catch (Dali::DaliException e) {
31753       {
31754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31755       };
31756     } catch (...) {
31757       {
31758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31759       };
31760     }
31761   }
31762
31763   jresult = (void *)result;
31764   return jresult;
31765 }
31766
31767
31768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31769   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31770   unsigned int arg2 ;
31771
31772   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31773   arg2 = (unsigned int)jarg2;
31774   {
31775     try {
31776       (arg1)->SetTouchesRequired(arg2);
31777     } catch (std::out_of_range& e) {
31778       {
31779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31780       };
31781     } catch (std::exception& e) {
31782       {
31783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31784       };
31785     } catch (Dali::DaliException e) {
31786       {
31787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31788       };
31789     } catch (...) {
31790       {
31791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31792       };
31793     }
31794   }
31795
31796 }
31797
31798
31799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31800   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31801   unsigned int arg2 ;
31802   unsigned int arg3 ;
31803
31804   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31805   arg2 = (unsigned int)jarg2;
31806   arg3 = (unsigned int)jarg3;
31807   {
31808     try {
31809       (arg1)->SetTouchesRequired(arg2,arg3);
31810     } catch (std::out_of_range& e) {
31811       {
31812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31813       };
31814     } catch (std::exception& e) {
31815       {
31816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31817       };
31818     } catch (Dali::DaliException e) {
31819       {
31820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31821       };
31822     } catch (...) {
31823       {
31824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31825       };
31826     }
31827   }
31828
31829 }
31830
31831
31832 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31833   unsigned int jresult ;
31834   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31835   unsigned int result;
31836
31837   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31838   {
31839     try {
31840       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31841     } catch (std::out_of_range& e) {
31842       {
31843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31844       };
31845     } catch (std::exception& e) {
31846       {
31847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31848       };
31849     } catch (Dali::DaliException e) {
31850       {
31851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31852       };
31853     } catch (...) {
31854       {
31855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31856       };
31857     }
31858   }
31859
31860   jresult = result;
31861   return jresult;
31862 }
31863
31864
31865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31866   unsigned int jresult ;
31867   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31868   unsigned int result;
31869
31870   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31871   {
31872     try {
31873       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31874     } catch (std::out_of_range& e) {
31875       {
31876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31877       };
31878     } catch (std::exception& e) {
31879       {
31880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31881       };
31882     } catch (Dali::DaliException e) {
31883       {
31884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31885       };
31886     } catch (...) {
31887       {
31888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31889       };
31890     }
31891   }
31892
31893   jresult = result;
31894   return jresult;
31895 }
31896
31897
31898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31899   void * jresult ;
31900   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31901   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31902
31903   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31904   {
31905     try {
31906       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31907     } catch (std::out_of_range& e) {
31908       {
31909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31910       };
31911     } catch (std::exception& e) {
31912       {
31913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31914       };
31915     } catch (Dali::DaliException e) {
31916       {
31917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31918       };
31919     } catch (...) {
31920       {
31921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31922       };
31923     }
31924   }
31925
31926   jresult = (void *)result;
31927   return jresult;
31928 }
31929
31930
31931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31932   void * jresult ;
31933   Dali::Gesture::State arg1 ;
31934   Dali::LongPressGesture *result = 0 ;
31935
31936   arg1 = (Dali::Gesture::State)jarg1;
31937   {
31938     try {
31939       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31940     } catch (std::out_of_range& e) {
31941       {
31942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31943       };
31944     } catch (std::exception& e) {
31945       {
31946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31947       };
31948     } catch (Dali::DaliException e) {
31949       {
31950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31951       };
31952     } catch (...) {
31953       {
31954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31955       };
31956     }
31957   }
31958
31959   jresult = (void *)result;
31960   return jresult;
31961 }
31962
31963
31964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31965   void * jresult ;
31966   Dali::LongPressGesture *arg1 = 0 ;
31967   Dali::LongPressGesture *result = 0 ;
31968
31969   arg1 = (Dali::LongPressGesture *)jarg1;
31970   if (!arg1) {
31971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31972     return 0;
31973   }
31974   {
31975     try {
31976       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31977     } catch (std::out_of_range& e) {
31978       {
31979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31980       };
31981     } catch (std::exception& e) {
31982       {
31983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31984       };
31985     } catch (Dali::DaliException e) {
31986       {
31987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31988       };
31989     } catch (...) {
31990       {
31991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31992       };
31993     }
31994   }
31995
31996   jresult = (void *)result;
31997   return jresult;
31998 }
31999
32000
32001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32002   void * jresult ;
32003   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32004   Dali::LongPressGesture *arg2 = 0 ;
32005   Dali::LongPressGesture *result = 0 ;
32006
32007   arg1 = (Dali::LongPressGesture *)jarg1;
32008   arg2 = (Dali::LongPressGesture *)jarg2;
32009   if (!arg2) {
32010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32011     return 0;
32012   }
32013   {
32014     try {
32015       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
32016     } catch (std::out_of_range& e) {
32017       {
32018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32019       };
32020     } catch (std::exception& e) {
32021       {
32022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32023       };
32024     } catch (Dali::DaliException e) {
32025       {
32026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32027       };
32028     } catch (...) {
32029       {
32030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32031       };
32032     }
32033   }
32034
32035   jresult = (void *)result;
32036   return jresult;
32037 }
32038
32039
32040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32041   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32042
32043   arg1 = (Dali::LongPressGesture *)jarg1;
32044   {
32045     try {
32046       delete arg1;
32047     } catch (std::out_of_range& e) {
32048       {
32049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32050       };
32051     } catch (std::exception& e) {
32052       {
32053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32054       };
32055     } catch (Dali::DaliException e) {
32056       {
32057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32058       };
32059     } catch (...) {
32060       {
32061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32062       };
32063     }
32064   }
32065
32066 }
32067
32068
32069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32070   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32071   unsigned int arg2 ;
32072
32073   arg1 = (Dali::LongPressGesture *)jarg1;
32074   arg2 = (unsigned int)jarg2;
32075   if (arg1) (arg1)->numberOfTouches = arg2;
32076 }
32077
32078
32079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32080   unsigned int jresult ;
32081   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32082   unsigned int result;
32083
32084   arg1 = (Dali::LongPressGesture *)jarg1;
32085   result = (unsigned int) ((arg1)->numberOfTouches);
32086   jresult = result;
32087   return jresult;
32088 }
32089
32090
32091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32092   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32093   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32094
32095   arg1 = (Dali::LongPressGesture *)jarg1;
32096   arg2 = (Dali::Vector2 *)jarg2;
32097   if (arg1) (arg1)->screenPoint = *arg2;
32098 }
32099
32100
32101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32102   void * jresult ;
32103   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32104   Dali::Vector2 *result = 0 ;
32105
32106   arg1 = (Dali::LongPressGesture *)jarg1;
32107   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32108   jresult = (void *)result;
32109   return jresult;
32110 }
32111
32112
32113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32114   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32115   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32116
32117   arg1 = (Dali::LongPressGesture *)jarg1;
32118   arg2 = (Dali::Vector2 *)jarg2;
32119   if (arg1) (arg1)->localPoint = *arg2;
32120 }
32121
32122
32123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32124   void * jresult ;
32125   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32126   Dali::Vector2 *result = 0 ;
32127
32128   arg1 = (Dali::LongPressGesture *)jarg1;
32129   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32130   jresult = (void *)result;
32131   return jresult;
32132 }
32133
32134
32135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32136   void * jresult ;
32137   Dali::WheelEvent *result = 0 ;
32138
32139   {
32140     try {
32141       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32142     } catch (std::out_of_range& e) {
32143       {
32144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32145       };
32146     } catch (std::exception& e) {
32147       {
32148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32149       };
32150     } catch (Dali::DaliException e) {
32151       {
32152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32153       };
32154     } catch (...) {
32155       {
32156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32157       };
32158     }
32159   }
32160
32161   jresult = (void *)result;
32162   return jresult;
32163 }
32164
32165
32166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32167   void * jresult ;
32168   Dali::WheelEvent::Type arg1 ;
32169   int arg2 ;
32170   unsigned int arg3 ;
32171   Dali::Vector2 arg4 ;
32172   int arg5 ;
32173   unsigned int arg6 ;
32174   Dali::Vector2 *argp4 ;
32175   Dali::WheelEvent *result = 0 ;
32176
32177   arg1 = (Dali::WheelEvent::Type)jarg1;
32178   arg2 = (int)jarg2;
32179   arg3 = (unsigned int)jarg3;
32180   argp4 = (Dali::Vector2 *)jarg4;
32181   if (!argp4) {
32182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32183     return 0;
32184   }
32185   arg4 = *argp4;
32186   arg5 = (int)jarg5;
32187   arg6 = (unsigned int)jarg6;
32188   {
32189     try {
32190       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32191     } catch (std::out_of_range& e) {
32192       {
32193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32194       };
32195     } catch (std::exception& e) {
32196       {
32197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32198       };
32199     } catch (Dali::DaliException e) {
32200       {
32201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32202       };
32203     } catch (...) {
32204       {
32205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32206       };
32207     }
32208   }
32209
32210   jresult = (void *)result;
32211   return jresult;
32212 }
32213
32214
32215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32216   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32217
32218   arg1 = (Dali::WheelEvent *)jarg1;
32219   {
32220     try {
32221       delete arg1;
32222     } catch (std::out_of_range& e) {
32223       {
32224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32225       };
32226     } catch (std::exception& e) {
32227       {
32228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32229       };
32230     } catch (Dali::DaliException e) {
32231       {
32232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32233       };
32234     } catch (...) {
32235       {
32236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32237       };
32238     }
32239   }
32240
32241 }
32242
32243
32244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32245   unsigned int jresult ;
32246   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32247   bool result;
32248
32249   arg1 = (Dali::WheelEvent *)jarg1;
32250   {
32251     try {
32252       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32253     } catch (std::out_of_range& e) {
32254       {
32255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32256       };
32257     } catch (std::exception& e) {
32258       {
32259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32260       };
32261     } catch (Dali::DaliException e) {
32262       {
32263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32264       };
32265     } catch (...) {
32266       {
32267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32268       };
32269     }
32270   }
32271
32272   jresult = result;
32273   return jresult;
32274 }
32275
32276
32277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32278   unsigned int jresult ;
32279   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32280   bool result;
32281
32282   arg1 = (Dali::WheelEvent *)jarg1;
32283   {
32284     try {
32285       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32286     } catch (std::out_of_range& e) {
32287       {
32288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32289       };
32290     } catch (std::exception& e) {
32291       {
32292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32293       };
32294     } catch (Dali::DaliException e) {
32295       {
32296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32297       };
32298     } catch (...) {
32299       {
32300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32301       };
32302     }
32303   }
32304
32305   jresult = result;
32306   return jresult;
32307 }
32308
32309
32310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32311   unsigned int jresult ;
32312   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32313   bool result;
32314
32315   arg1 = (Dali::WheelEvent *)jarg1;
32316   {
32317     try {
32318       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32319     } catch (std::out_of_range& e) {
32320       {
32321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32322       };
32323     } catch (std::exception& e) {
32324       {
32325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32326       };
32327     } catch (Dali::DaliException e) {
32328       {
32329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32330       };
32331     } catch (...) {
32332       {
32333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32334       };
32335     }
32336   }
32337
32338   jresult = result;
32339   return jresult;
32340 }
32341
32342
32343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32344   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32345   Dali::WheelEvent::Type arg2 ;
32346
32347   arg1 = (Dali::WheelEvent *)jarg1;
32348   arg2 = (Dali::WheelEvent::Type)jarg2;
32349   if (arg1) (arg1)->type = arg2;
32350 }
32351
32352
32353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32354   int jresult ;
32355   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32356   Dali::WheelEvent::Type result;
32357
32358   arg1 = (Dali::WheelEvent *)jarg1;
32359   result = (Dali::WheelEvent::Type) ((arg1)->type);
32360   jresult = (int)result;
32361   return jresult;
32362 }
32363
32364
32365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32366   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32367   int arg2 ;
32368
32369   arg1 = (Dali::WheelEvent *)jarg1;
32370   arg2 = (int)jarg2;
32371   if (arg1) (arg1)->direction = arg2;
32372 }
32373
32374
32375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32376   int jresult ;
32377   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32378   int result;
32379
32380   arg1 = (Dali::WheelEvent *)jarg1;
32381   result = (int) ((arg1)->direction);
32382   jresult = result;
32383   return jresult;
32384 }
32385
32386
32387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32388   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32389   unsigned int arg2 ;
32390
32391   arg1 = (Dali::WheelEvent *)jarg1;
32392   arg2 = (unsigned int)jarg2;
32393   if (arg1) (arg1)->modifiers = arg2;
32394 }
32395
32396
32397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32398   unsigned int jresult ;
32399   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32400   unsigned int result;
32401
32402   arg1 = (Dali::WheelEvent *)jarg1;
32403   result = (unsigned int) ((arg1)->modifiers);
32404   jresult = result;
32405   return jresult;
32406 }
32407
32408
32409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32410   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32411   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32412
32413   arg1 = (Dali::WheelEvent *)jarg1;
32414   arg2 = (Dali::Vector2 *)jarg2;
32415   if (arg1) (arg1)->point = *arg2;
32416 }
32417
32418
32419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32420   void * jresult ;
32421   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32422   Dali::Vector2 *result = 0 ;
32423
32424   arg1 = (Dali::WheelEvent *)jarg1;
32425   result = (Dali::Vector2 *)& ((arg1)->point);
32426   jresult = (void *)result;
32427   return jresult;
32428 }
32429
32430
32431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32432   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32433   int arg2 ;
32434
32435   arg1 = (Dali::WheelEvent *)jarg1;
32436   arg2 = (int)jarg2;
32437   if (arg1) (arg1)->z = arg2;
32438 }
32439
32440
32441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32442   int jresult ;
32443   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32444   int result;
32445
32446   arg1 = (Dali::WheelEvent *)jarg1;
32447   result = (int) ((arg1)->z);
32448   jresult = result;
32449   return jresult;
32450 }
32451
32452
32453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32454   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32455   unsigned int arg2 ;
32456
32457   arg1 = (Dali::WheelEvent *)jarg1;
32458   arg2 = (unsigned int)jarg2;
32459   if (arg1) (arg1)->timeStamp = arg2;
32460 }
32461
32462
32463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32464   unsigned int jresult ;
32465   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32466   unsigned int result;
32467
32468   arg1 = (Dali::WheelEvent *)jarg1;
32469   result = (unsigned int) ((arg1)->timeStamp);
32470   jresult = result;
32471   return jresult;
32472 }
32473
32474 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32475   char * jresult ;
32476   Dali::KeyEvent *arg1 = 0 ;
32477   std::string result;
32478
32479   arg1 = (Dali::KeyEvent *)jarg1;
32480   if (!arg1) {
32481     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32482     return 0;
32483   }
32484   {
32485     try {
32486       result = arg1->GetDeviceName();
32487     } catch (std::out_of_range& e) {
32488       {
32489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32490       };
32491     } catch (std::exception& e) {
32492       {
32493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32494       };
32495     } catch (Dali::DaliException e) {
32496       {
32497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32498       };
32499     } catch (...) {
32500       {
32501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32502       };
32503     }
32504   }
32505
32506   jresult = SWIG_csharp_string_callback((&result)->c_str());
32507   return jresult;
32508 }
32509
32510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32511   int jresult ;
32512   Dali::KeyEvent *arg1 = 0 ;
32513   Dali::Device::Class::Type result;
32514
32515   arg1 = (Dali::KeyEvent *)jarg1;
32516   if (!arg1) {
32517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32518     return 0;
32519   }
32520   {
32521     try {
32522       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32523     } catch (std::out_of_range& e) {
32524       {
32525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32526       };
32527     } catch (std::exception& e) {
32528       {
32529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32530       };
32531     } catch (Dali::DaliException e) {
32532       {
32533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32534       };
32535     } catch (...) {
32536       {
32537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32538       };
32539     }
32540   }
32541
32542   jresult = (int)result;
32543   return jresult;
32544 }
32545
32546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32547   int jresult ;
32548   Dali::KeyEvent *arg1 = 0 ;
32549   Dali::Device::Subclass::Type result;
32550
32551   arg1 = (Dali::KeyEvent *)jarg1;
32552   if (!arg1) {
32553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32554     return 0;
32555   }
32556   {
32557     try {
32558       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32559     } catch (std::out_of_range& e) {
32560       {
32561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32562       };
32563     } catch (std::exception& e) {
32564       {
32565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32566       };
32567     } catch (Dali::DaliException e) {
32568       {
32569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32570       };
32571     } catch (...) {
32572       {
32573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32574       };
32575     }
32576   }
32577
32578   jresult = (int)result;
32579   return jresult;
32580 }
32581
32582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32583   Dali::Actor arg1 ;
32584   Dali::Actor *argp1 ;
32585
32586   argp1 = (Dali::Actor *)jarg1;
32587   if (!argp1) {
32588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32589     return ;
32590   }
32591   arg1 = *argp1;
32592   {
32593     try {
32594       arg1.Raise();
32595     } catch (std::out_of_range& e) {
32596       {
32597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32598       };
32599     } catch (std::exception& e) {
32600       {
32601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32602       };
32603     } catch (Dali::DaliException e) {
32604       {
32605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32606       };
32607     } catch (...) {
32608       {
32609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32610       };
32611     }
32612   }
32613
32614 }
32615
32616
32617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32618   Dali::Actor arg1 ;
32619   Dali::Actor *argp1 ;
32620
32621   argp1 = (Dali::Actor *)jarg1;
32622   if (!argp1) {
32623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32624     return ;
32625   }
32626   arg1 = *argp1;
32627   {
32628     try {
32629       arg1.Lower();
32630     } catch (std::out_of_range& e) {
32631       {
32632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32633       };
32634     } catch (std::exception& e) {
32635       {
32636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32637       };
32638     } catch (Dali::DaliException e) {
32639       {
32640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32641       };
32642     } catch (...) {
32643       {
32644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32645       };
32646     }
32647   }
32648
32649 }
32650
32651
32652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32653   Dali::Actor arg1 ;
32654   Dali::Actor *argp1 ;
32655
32656   argp1 = (Dali::Actor *)jarg1;
32657   if (!argp1) {
32658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32659     return ;
32660   }
32661   arg1 = *argp1;
32662   {
32663     try {
32664       arg1.RaiseToTop();
32665     } catch (std::out_of_range& e) {
32666       {
32667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32668       };
32669     } catch (std::exception& e) {
32670       {
32671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32672       };
32673     } catch (Dali::DaliException e) {
32674       {
32675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32676       };
32677     } catch (...) {
32678       {
32679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32680       };
32681     }
32682   }
32683
32684 }
32685
32686
32687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32688   Dali::Actor arg1 ;
32689   Dali::Actor *argp1 ;
32690
32691   argp1 = (Dali::Actor *)jarg1;
32692   if (!argp1) {
32693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32694     return ;
32695   }
32696   arg1 = *argp1;
32697   {
32698     try {
32699       arg1.LowerToBottom();
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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32722   Dali::Actor arg1 ;
32723   Dali::Actor arg2 ;
32724   Dali::Actor *argp1 ;
32725   Dali::Actor *argp2 ;
32726
32727   argp1 = (Dali::Actor *)jarg1;
32728   if (!argp1) {
32729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32730     return ;
32731   }
32732   arg1 = *argp1;
32733   argp2 = (Dali::Actor *)jarg2;
32734   if (!argp2) {
32735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32736     return ;
32737   }
32738   arg2 = *argp2;
32739   {
32740     try {
32741       arg1.RaiseAbove(arg2);
32742     } catch (std::out_of_range& e) {
32743       {
32744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32745       };
32746     } catch (std::exception& e) {
32747       {
32748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32749       };
32750     } catch (Dali::DaliException e) {
32751       {
32752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32753       };
32754     } catch (...) {
32755       {
32756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32757       };
32758     }
32759   }
32760
32761 }
32762
32763
32764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32765   Dali::Actor arg1 ;
32766   Dali::Actor arg2 ;
32767   Dali::Actor *argp1 ;
32768   Dali::Actor *argp2 ;
32769
32770   argp1 = (Dali::Actor *)jarg1;
32771   if (!argp1) {
32772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32773     return ;
32774   }
32775   arg1 = *argp1;
32776   argp2 = (Dali::Actor *)jarg2;
32777   if (!argp2) {
32778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32779     return ;
32780   }
32781   arg2 = *argp2;
32782   {
32783     try {
32784       arg1.LowerBelow(arg2);
32785     } catch (std::out_of_range& e) {
32786       {
32787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32788       };
32789     } catch (std::exception& e) {
32790       {
32791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32792       };
32793     } catch (Dali::DaliException e) {
32794       {
32795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32796       };
32797     } catch (...) {
32798       {
32799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32800       };
32801     }
32802   }
32803
32804 }
32805
32806
32807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32808   void * jresult ;
32809   Dali::Actor arg1 ;
32810   Dali::Actor *argp1 ;
32811   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32812
32813   argp1 = (Dali::Actor *)jarg1;
32814   if (!argp1) {
32815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32816     return 0;
32817   }
32818   arg1 = *argp1;
32819   {
32820     try {
32821       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32822     } catch (std::out_of_range& e) {
32823       {
32824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32825       };
32826     } catch (std::exception& e) {
32827       {
32828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32829       };
32830     } catch (Dali::DaliException e) {
32831       {
32832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32833       };
32834     } catch (...) {
32835       {
32836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32837       };
32838     }
32839   }
32840
32841   jresult = (void *)result;
32842   return jresult;
32843 }
32844
32845
32846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32847   void * jresult ;
32848   Dali::Actor *arg1 ;
32849   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32850
32851   arg1 = (Dali::Actor *)jarg1;
32852   {
32853     try {
32854       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32855     } catch (std::out_of_range& e) {
32856       {
32857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32858       };
32859     } catch (std::exception& e) {
32860       {
32861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32862       };
32863     } catch (Dali::DaliException e) {
32864       {
32865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32866       };
32867     } catch (...) {
32868       {
32869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32870       };
32871     }
32872   }
32873
32874   jresult = (void *)result;
32875   return jresult;
32876 }
32877
32878
32879 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32880   int jresult ;
32881   int result;
32882
32883   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32884   jresult = (int)result;
32885   return jresult;
32886 }
32887
32888
32889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32890   int jresult ;
32891   int result;
32892
32893   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32894   jresult = (int)result;
32895   return jresult;
32896 }
32897
32898
32899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32900   int jresult ;
32901   int result;
32902
32903   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32904   jresult = (int)result;
32905   return jresult;
32906 }
32907
32908
32909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32910   int jresult ;
32911   int result;
32912
32913   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32914   jresult = (int)result;
32915   return jresult;
32916 }
32917
32918
32919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32920   int jresult ;
32921   int result;
32922
32923   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32924   jresult = (int)result;
32925   return jresult;
32926 }
32927
32928
32929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32930   int jresult ;
32931   int result;
32932
32933   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32934   jresult = (int)result;
32935   return jresult;
32936 }
32937
32938
32939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32940   int jresult ;
32941   int result;
32942
32943   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32944   jresult = (int)result;
32945   return jresult;
32946 }
32947
32948
32949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32950   int jresult ;
32951   int result;
32952
32953   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32954   jresult = (int)result;
32955   return jresult;
32956 }
32957
32958
32959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32960   int jresult ;
32961   int result;
32962
32963   result = (int)Dali::Actor::Property::SIZE;
32964   jresult = (int)result;
32965   return jresult;
32966 }
32967
32968
32969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32970   int jresult ;
32971   int result;
32972
32973   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32974   jresult = (int)result;
32975   return jresult;
32976 }
32977
32978
32979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32980   int jresult ;
32981   int result;
32982
32983   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32984   jresult = (int)result;
32985   return jresult;
32986 }
32987
32988
32989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32990   int jresult ;
32991   int result;
32992
32993   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32994   jresult = (int)result;
32995   return jresult;
32996 }
32997
32998
32999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33000   int jresult ;
33001   int result;
33002
33003   result = (int)Dali::Actor::Property::POSITION;
33004   jresult = (int)result;
33005   return jresult;
33006 }
33007
33008
33009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33010   int jresult ;
33011   int result;
33012
33013   result = (int)Dali::Actor::Property::POSITION_X;
33014   jresult = (int)result;
33015   return jresult;
33016 }
33017
33018
33019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33020   int jresult ;
33021   int result;
33022
33023   result = (int)Dali::Actor::Property::POSITION_Y;
33024   jresult = (int)result;
33025   return jresult;
33026 }
33027
33028
33029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33030   int jresult ;
33031   int result;
33032
33033   result = (int)Dali::Actor::Property::POSITION_Z;
33034   jresult = (int)result;
33035   return jresult;
33036 }
33037
33038
33039 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33040   int jresult ;
33041   int result;
33042
33043   result = (int)Dali::Actor::Property::WORLD_POSITION;
33044   jresult = (int)result;
33045   return jresult;
33046 }
33047
33048
33049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33050   int jresult ;
33051   int result;
33052
33053   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33054   jresult = (int)result;
33055   return jresult;
33056 }
33057
33058
33059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33060   int jresult ;
33061   int result;
33062
33063   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33064   jresult = (int)result;
33065   return jresult;
33066 }
33067
33068
33069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33070   int jresult ;
33071   int result;
33072
33073   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33074   jresult = (int)result;
33075   return jresult;
33076 }
33077
33078
33079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33080   int jresult ;
33081   int result;
33082
33083   result = (int)Dali::Actor::Property::ORIENTATION;
33084   jresult = (int)result;
33085   return jresult;
33086 }
33087
33088
33089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33090   int jresult ;
33091   int result;
33092
33093   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33094   jresult = (int)result;
33095   return jresult;
33096 }
33097
33098
33099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33100   int jresult ;
33101   int result;
33102
33103   result = (int)Dali::Actor::Property::SCALE;
33104   jresult = (int)result;
33105   return jresult;
33106 }
33107
33108
33109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33110   int jresult ;
33111   int result;
33112
33113   result = (int)Dali::Actor::Property::SCALE_X;
33114   jresult = (int)result;
33115   return jresult;
33116 }
33117
33118
33119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33120   int jresult ;
33121   int result;
33122
33123   result = (int)Dali::Actor::Property::SCALE_Y;
33124   jresult = (int)result;
33125   return jresult;
33126 }
33127
33128
33129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33130   int jresult ;
33131   int result;
33132
33133   result = (int)Dali::Actor::Property::SCALE_Z;
33134   jresult = (int)result;
33135   return jresult;
33136 }
33137
33138
33139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33140   int jresult ;
33141   int result;
33142
33143   result = (int)Dali::Actor::Property::WORLD_SCALE;
33144   jresult = (int)result;
33145   return jresult;
33146 }
33147
33148
33149 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33150   int jresult ;
33151   int result;
33152
33153   result = (int)Dali::Actor::Property::VISIBLE;
33154   jresult = (int)result;
33155   return jresult;
33156 }
33157
33158
33159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33160   int jresult ;
33161   int result;
33162
33163   result = (int)Dali::Actor::Property::COLOR;
33164   jresult = (int)result;
33165   return jresult;
33166 }
33167
33168
33169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33170   int jresult ;
33171   int result;
33172
33173   result = (int)Dali::Actor::Property::COLOR_RED;
33174   jresult = (int)result;
33175   return jresult;
33176 }
33177
33178
33179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33180   int jresult ;
33181   int result;
33182
33183   result = (int)Dali::Actor::Property::COLOR_GREEN;
33184   jresult = (int)result;
33185   return jresult;
33186 }
33187
33188
33189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33190   int jresult ;
33191   int result;
33192
33193   result = (int)Dali::Actor::Property::COLOR_BLUE;
33194   jresult = (int)result;
33195   return jresult;
33196 }
33197
33198
33199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33200   int jresult ;
33201   int result;
33202
33203   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33204   jresult = (int)result;
33205   return jresult;
33206 }
33207
33208
33209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33210   int jresult ;
33211   int result;
33212
33213   result = (int)Dali::Actor::Property::WORLD_COLOR;
33214   jresult = (int)result;
33215   return jresult;
33216 }
33217
33218
33219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33220   int jresult ;
33221   int result;
33222
33223   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33224   jresult = (int)result;
33225   return jresult;
33226 }
33227
33228
33229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33230   int jresult ;
33231   int result;
33232
33233   result = (int)Dali::Actor::Property::NAME;
33234   jresult = (int)result;
33235   return jresult;
33236 }
33237
33238
33239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33240   int jresult ;
33241   int result;
33242
33243   result = (int)Dali::Actor::Property::SENSITIVE;
33244   jresult = (int)result;
33245   return jresult;
33246 }
33247
33248
33249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33250   int jresult ;
33251   int result;
33252
33253   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33254   jresult = (int)result;
33255   return jresult;
33256 }
33257
33258
33259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33260   int jresult ;
33261   int result;
33262
33263   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33264   jresult = (int)result;
33265   return jresult;
33266 }
33267
33268
33269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33270   int jresult ;
33271   int result;
33272
33273   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33274   jresult = (int)result;
33275   return jresult;
33276 }
33277
33278
33279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33280   int jresult ;
33281   int result;
33282
33283   result = (int)Dali::Actor::Property::COLOR_MODE;
33284   jresult = (int)result;
33285   return jresult;
33286 }
33287
33288
33289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33290   int jresult ;
33291   int result;
33292
33293   result = (int)Dali::Actor::Property::DRAW_MODE;
33294   jresult = (int)result;
33295   return jresult;
33296 }
33297
33298
33299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33300   int jresult ;
33301   int result;
33302
33303   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33304   jresult = (int)result;
33305   return jresult;
33306 }
33307
33308
33309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33310   int jresult ;
33311   int result;
33312
33313   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33314   jresult = (int)result;
33315   return jresult;
33316 }
33317
33318
33319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33320   int jresult ;
33321   int result;
33322
33323   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33324   jresult = (int)result;
33325   return jresult;
33326 }
33327
33328
33329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33330   int jresult ;
33331   int result;
33332
33333   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33334   jresult = (int)result;
33335   return jresult;
33336 }
33337
33338
33339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33340   int jresult ;
33341   int result;
33342
33343   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33344   jresult = (int)result;
33345   return jresult;
33346 }
33347
33348
33349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33350   int jresult ;
33351   int result;
33352
33353   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33354   jresult = (int)result;
33355   return jresult;
33356 }
33357
33358
33359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33360   int jresult ;
33361   int result;
33362
33363   result = (int)Dali::Actor::Property::PADDING;
33364   jresult = (int)result;
33365   return jresult;
33366 }
33367
33368
33369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33370   int jresult ;
33371   int result;
33372
33373   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33374   jresult = (int)result;
33375   return jresult;
33376 }
33377
33378
33379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33380   int jresult ;
33381   int result;
33382
33383   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33384   jresult = (int)result;
33385   return jresult;
33386 }
33387
33388
33389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33390   int jresult ;
33391   int result;
33392
33393   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33394   jresult = (int)result;
33395   return jresult;
33396 }
33397
33398
33399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33400   int jresult ;
33401   int result;
33402
33403   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33404   jresult = (int)result;
33405   return jresult;
33406 }
33407
33408
33409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33410   void * jresult ;
33411   Dali::Actor::Property *result = 0 ;
33412
33413   {
33414     try {
33415       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33416     } catch (std::out_of_range& e) {
33417       {
33418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33419       };
33420     } catch (std::exception& e) {
33421       {
33422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33423       };
33424     } catch (Dali::DaliException e) {
33425       {
33426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33427       };
33428     } catch (...) {
33429       {
33430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33431       };
33432     }
33433   }
33434
33435   jresult = (void *)result;
33436   return jresult;
33437 }
33438
33439
33440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33441   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33442
33443   arg1 = (Dali::Actor::Property *)jarg1;
33444   {
33445     try {
33446       delete arg1;
33447     } catch (std::out_of_range& e) {
33448       {
33449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33450       };
33451     } catch (std::exception& e) {
33452       {
33453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33454       };
33455     } catch (Dali::DaliException e) {
33456       {
33457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33458       };
33459     } catch (...) {
33460       {
33461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33462       };
33463     }
33464   }
33465
33466 }
33467
33468
33469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33470   void * jresult ;
33471   Dali::Actor *result = 0 ;
33472
33473   {
33474     try {
33475       result = (Dali::Actor *)new Dali::Actor();
33476     } catch (std::out_of_range& e) {
33477       {
33478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33479       };
33480     } catch (std::exception& e) {
33481       {
33482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33483       };
33484     } catch (Dali::DaliException e) {
33485       {
33486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33487       };
33488     } catch (...) {
33489       {
33490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33491       };
33492     }
33493   }
33494
33495   jresult = (void *)result;
33496   return jresult;
33497 }
33498
33499
33500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33501   void * jresult ;
33502   Dali::Actor result;
33503
33504   {
33505     try {
33506       result = Dali::Actor::New();
33507     } catch (std::out_of_range& e) {
33508       {
33509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33510       };
33511     } catch (std::exception& e) {
33512       {
33513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33514       };
33515     } catch (Dali::DaliException e) {
33516       {
33517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33518       };
33519     } catch (...) {
33520       {
33521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33522       };
33523     }
33524   }
33525
33526   jresult = new Dali::Actor((const Dali::Actor &)result);
33527   return jresult;
33528 }
33529
33530
33531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33532   void * jresult ;
33533   Dali::BaseHandle arg1 ;
33534   Dali::BaseHandle *argp1 ;
33535   Dali::Actor result;
33536
33537   argp1 = (Dali::BaseHandle *)jarg1;
33538   if (!argp1) {
33539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33540     return 0;
33541   }
33542   arg1 = *argp1;
33543   {
33544     try {
33545       result = Dali::Actor::DownCast(arg1);
33546     } catch (std::out_of_range& e) {
33547       {
33548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33549       };
33550     } catch (std::exception& e) {
33551       {
33552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33553       };
33554     } catch (Dali::DaliException e) {
33555       {
33556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33557       };
33558     } catch (...) {
33559       {
33560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33561       };
33562     }
33563   }
33564
33565   jresult = new Dali::Actor((const Dali::Actor &)result);
33566   return jresult;
33567 }
33568
33569
33570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33571   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33572
33573   arg1 = (Dali::Actor *)jarg1;
33574   {
33575     try {
33576       delete arg1;
33577     } catch (std::out_of_range& e) {
33578       {
33579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33580       };
33581     } catch (std::exception& e) {
33582       {
33583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33584       };
33585     } catch (Dali::DaliException e) {
33586       {
33587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33588       };
33589     } catch (...) {
33590       {
33591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33592       };
33593     }
33594   }
33595
33596 }
33597
33598
33599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33600   void * jresult ;
33601   Dali::Actor *arg1 = 0 ;
33602   Dali::Actor *result = 0 ;
33603
33604   arg1 = (Dali::Actor *)jarg1;
33605   if (!arg1) {
33606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33607     return 0;
33608   }
33609   {
33610     try {
33611       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33612     } catch (std::out_of_range& e) {
33613       {
33614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33615       };
33616     } catch (std::exception& e) {
33617       {
33618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33619       };
33620     } catch (Dali::DaliException e) {
33621       {
33622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33623       };
33624     } catch (...) {
33625       {
33626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33627       };
33628     }
33629   }
33630
33631   jresult = (void *)result;
33632   return jresult;
33633 }
33634
33635
33636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33637   void * jresult ;
33638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33639   Dali::Actor *arg2 = 0 ;
33640   Dali::Actor *result = 0 ;
33641
33642   arg1 = (Dali::Actor *)jarg1;
33643   arg2 = (Dali::Actor *)jarg2;
33644   if (!arg2) {
33645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33646     return 0;
33647   }
33648   {
33649     try {
33650       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33651     } catch (std::out_of_range& e) {
33652       {
33653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33654       };
33655     } catch (std::exception& e) {
33656       {
33657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33658       };
33659     } catch (Dali::DaliException e) {
33660       {
33661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33662       };
33663     } catch (...) {
33664       {
33665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33666       };
33667     }
33668   }
33669
33670   jresult = (void *)result;
33671   return jresult;
33672 }
33673
33674
33675 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33676   char * jresult ;
33677   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33678   std::string *result = 0 ;
33679
33680   arg1 = (Dali::Actor *)jarg1;
33681   {
33682     try {
33683       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33684     } catch (std::out_of_range& e) {
33685       {
33686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33687       };
33688     } catch (std::exception& e) {
33689       {
33690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33691       };
33692     } catch (Dali::DaliException e) {
33693       {
33694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33695       };
33696     } catch (...) {
33697       {
33698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33699       };
33700     }
33701   }
33702
33703   jresult = SWIG_csharp_string_callback(result->c_str());
33704   return jresult;
33705 }
33706
33707
33708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33709   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33710   std::string *arg2 = 0 ;
33711
33712   arg1 = (Dali::Actor *)jarg1;
33713   if (!jarg2) {
33714     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33715     return ;
33716   }
33717   std::string arg2_str(jarg2);
33718   arg2 = &arg2_str;
33719   {
33720     try {
33721       (arg1)->SetName((std::string const &)*arg2);
33722     } catch (std::out_of_range& e) {
33723       {
33724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33725       };
33726     } catch (std::exception& e) {
33727       {
33728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33729       };
33730     } catch (Dali::DaliException e) {
33731       {
33732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33733       };
33734     } catch (...) {
33735       {
33736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33737       };
33738     }
33739   }
33740
33741
33742   //argout typemap for const std::string&
33743
33744 }
33745
33746
33747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33748   unsigned int jresult ;
33749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33750   unsigned int result;
33751
33752   arg1 = (Dali::Actor *)jarg1;
33753   {
33754     try {
33755       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33756     } catch (std::out_of_range& e) {
33757       {
33758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33759       };
33760     } catch (std::exception& e) {
33761       {
33762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33763       };
33764     } catch (Dali::DaliException e) {
33765       {
33766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33767       };
33768     } catch (...) {
33769       {
33770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33771       };
33772     }
33773   }
33774
33775   jresult = result;
33776   return jresult;
33777 }
33778
33779
33780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33781   unsigned int jresult ;
33782   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33783   bool result;
33784
33785   arg1 = (Dali::Actor *)jarg1;
33786   {
33787     try {
33788       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33789     } catch (std::out_of_range& e) {
33790       {
33791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33792       };
33793     } catch (std::exception& e) {
33794       {
33795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33796       };
33797     } catch (Dali::DaliException e) {
33798       {
33799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33800       };
33801     } catch (...) {
33802       {
33803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33804       };
33805     }
33806   }
33807
33808   jresult = result;
33809   return jresult;
33810 }
33811
33812
33813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33814   unsigned int jresult ;
33815   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33816   bool result;
33817
33818   arg1 = (Dali::Actor *)jarg1;
33819   {
33820     try {
33821       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33822     } catch (std::out_of_range& e) {
33823       {
33824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33825       };
33826     } catch (std::exception& e) {
33827       {
33828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33829       };
33830     } catch (Dali::DaliException e) {
33831       {
33832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33833       };
33834     } catch (...) {
33835       {
33836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33837       };
33838     }
33839   }
33840
33841   jresult = result;
33842   return jresult;
33843 }
33844
33845
33846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33847   unsigned int jresult ;
33848   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33849   bool result;
33850
33851   arg1 = (Dali::Actor *)jarg1;
33852   {
33853     try {
33854       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33855     } catch (std::out_of_range& e) {
33856       {
33857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33858       };
33859     } catch (std::exception& e) {
33860       {
33861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33862       };
33863     } catch (Dali::DaliException e) {
33864       {
33865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33866       };
33867     } catch (...) {
33868       {
33869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33870       };
33871     }
33872   }
33873
33874   jresult = result;
33875   return jresult;
33876 }
33877
33878
33879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33880   void * jresult ;
33881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33882   Dali::Layer result;
33883
33884   arg1 = (Dali::Actor *)jarg1;
33885   {
33886     try {
33887       result = (arg1)->GetLayer();
33888     } catch (std::out_of_range& e) {
33889       {
33890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33891       };
33892     } catch (std::exception& e) {
33893       {
33894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33895       };
33896     } catch (Dali::DaliException e) {
33897       {
33898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33899       };
33900     } catch (...) {
33901       {
33902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33903       };
33904     }
33905   }
33906
33907   jresult = new Dali::Layer((const Dali::Layer &)result);
33908   return jresult;
33909 }
33910
33911
33912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33913   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33914   Dali::Actor arg2 ;
33915   Dali::Actor *argp2 ;
33916
33917   arg1 = (Dali::Actor *)jarg1;
33918   argp2 = (Dali::Actor *)jarg2;
33919   if (!argp2) {
33920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33921     return ;
33922   }
33923   arg2 = *argp2;
33924   {
33925     try {
33926       (arg1)->Add(arg2);
33927     } catch (std::out_of_range& e) {
33928       {
33929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33930       };
33931     } catch (std::exception& e) {
33932       {
33933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33934       };
33935     } catch (Dali::DaliException e) {
33936       {
33937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33938       };
33939     } catch (...) {
33940       {
33941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33942       };
33943     }
33944   }
33945
33946 }
33947
33948
33949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33950   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33951   Dali::Actor arg2 ;
33952   Dali::Actor *argp2 ;
33953
33954   arg1 = (Dali::Actor *)jarg1;
33955   argp2 = (Dali::Actor *)jarg2;
33956   if (!argp2) {
33957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33958     return ;
33959   }
33960   arg2 = *argp2;
33961   {
33962     try {
33963       (arg1)->Remove(arg2);
33964     } catch (std::out_of_range& e) {
33965       {
33966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33967       };
33968     } catch (std::exception& e) {
33969       {
33970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33971       };
33972     } catch (Dali::DaliException e) {
33973       {
33974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33975       };
33976     } catch (...) {
33977       {
33978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33979       };
33980     }
33981   }
33982
33983 }
33984
33985
33986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33987   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33988
33989   arg1 = (Dali::Actor *)jarg1;
33990   {
33991     try {
33992       (arg1)->Unparent();
33993     } catch (std::out_of_range& e) {
33994       {
33995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33996       };
33997     } catch (std::exception& e) {
33998       {
33999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34000       };
34001     } catch (Dali::DaliException e) {
34002       {
34003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34004       };
34005     } catch (...) {
34006       {
34007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34008       };
34009     }
34010   }
34011
34012 }
34013
34014
34015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34016   unsigned int jresult ;
34017   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34018   unsigned int result;
34019
34020   arg1 = (Dali::Actor *)jarg1;
34021   {
34022     try {
34023       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34024     } catch (std::out_of_range& e) {
34025       {
34026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34027       };
34028     } catch (std::exception& e) {
34029       {
34030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34031       };
34032     } catch (Dali::DaliException e) {
34033       {
34034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34035       };
34036     } catch (...) {
34037       {
34038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34039       };
34040     }
34041   }
34042
34043   jresult = result;
34044   return jresult;
34045 }
34046
34047
34048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34049   void * jresult ;
34050   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34051   unsigned int arg2 ;
34052   Dali::Actor result;
34053
34054   arg1 = (Dali::Actor *)jarg1;
34055   arg2 = (unsigned int)jarg2;
34056   {
34057     try {
34058       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34059     } catch (std::out_of_range& e) {
34060       {
34061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34062       };
34063     } catch (std::exception& e) {
34064       {
34065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34066       };
34067     } catch (Dali::DaliException e) {
34068       {
34069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34070       };
34071     } catch (...) {
34072       {
34073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34074       };
34075     }
34076   }
34077
34078   jresult = new Dali::Actor((const Dali::Actor &)result);
34079   return jresult;
34080 }
34081
34082
34083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34084   void * jresult ;
34085   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34086   std::string *arg2 = 0 ;
34087   Dali::Actor result;
34088
34089   arg1 = (Dali::Actor *)jarg1;
34090   if (!jarg2) {
34091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34092     return 0;
34093   }
34094   std::string arg2_str(jarg2);
34095   arg2 = &arg2_str;
34096   {
34097     try {
34098       result = (arg1)->FindChildByName((std::string const &)*arg2);
34099     } catch (std::out_of_range& e) {
34100       {
34101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34102       };
34103     } catch (std::exception& e) {
34104       {
34105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34106       };
34107     } catch (Dali::DaliException e) {
34108       {
34109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34110       };
34111     } catch (...) {
34112       {
34113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34114       };
34115     }
34116   }
34117
34118   jresult = new Dali::Actor((const Dali::Actor &)result);
34119
34120   //argout typemap for const std::string&
34121
34122   return jresult;
34123 }
34124
34125
34126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34127   void * jresult ;
34128   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34129   unsigned int arg2 ;
34130   Dali::Actor result;
34131
34132   arg1 = (Dali::Actor *)jarg1;
34133   arg2 = (unsigned int)jarg2;
34134   {
34135     try {
34136       result = (arg1)->FindChildById(arg2);
34137     } catch (std::out_of_range& e) {
34138       {
34139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34140       };
34141     } catch (std::exception& e) {
34142       {
34143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34144       };
34145     } catch (Dali::DaliException e) {
34146       {
34147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34148       };
34149     } catch (...) {
34150       {
34151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34152       };
34153     }
34154   }
34155
34156   jresult = new Dali::Actor((const Dali::Actor &)result);
34157   return jresult;
34158 }
34159
34160
34161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34162   void * jresult ;
34163   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34164   Dali::Actor result;
34165
34166   arg1 = (Dali::Actor *)jarg1;
34167   {
34168     try {
34169       result = ((Dali::Actor const *)arg1)->GetParent();
34170     } catch (std::out_of_range& e) {
34171       {
34172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34173       };
34174     } catch (std::exception& e) {
34175       {
34176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34177       };
34178     } catch (Dali::DaliException e) {
34179       {
34180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34181       };
34182     } catch (...) {
34183       {
34184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34185       };
34186     }
34187   }
34188
34189   jresult = new Dali::Actor((const Dali::Actor &)result);
34190   return jresult;
34191 }
34192
34193
34194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34195   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34196   Dali::Vector3 *arg2 = 0 ;
34197
34198   arg1 = (Dali::Actor *)jarg1;
34199   arg2 = (Dali::Vector3 *)jarg2;
34200   if (!arg2) {
34201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34202     return ;
34203   }
34204   {
34205     try {
34206       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34207     } catch (std::out_of_range& e) {
34208       {
34209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34210       };
34211     } catch (std::exception& e) {
34212       {
34213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34214       };
34215     } catch (Dali::DaliException e) {
34216       {
34217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34218       };
34219     } catch (...) {
34220       {
34221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34222       };
34223     }
34224   }
34225
34226 }
34227
34228
34229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34230   void * jresult ;
34231   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34232   Dali::Vector3 result;
34233
34234   arg1 = (Dali::Actor *)jarg1;
34235   {
34236     try {
34237       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34238     } catch (std::out_of_range& e) {
34239       {
34240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34241       };
34242     } catch (std::exception& e) {
34243       {
34244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34245       };
34246     } catch (Dali::DaliException e) {
34247       {
34248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34249       };
34250     } catch (...) {
34251       {
34252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34253       };
34254     }
34255   }
34256
34257   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34258   return jresult;
34259 }
34260
34261
34262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34263   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34264   Dali::Vector3 *arg2 = 0 ;
34265
34266   arg1 = (Dali::Actor *)jarg1;
34267   arg2 = (Dali::Vector3 *)jarg2;
34268   if (!arg2) {
34269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34270     return ;
34271   }
34272   {
34273     try {
34274       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34275     } catch (std::out_of_range& e) {
34276       {
34277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34278       };
34279     } catch (std::exception& e) {
34280       {
34281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34282       };
34283     } catch (Dali::DaliException e) {
34284       {
34285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34286       };
34287     } catch (...) {
34288       {
34289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34290       };
34291     }
34292   }
34293
34294 }
34295
34296
34297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34298   void * jresult ;
34299   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34300   Dali::Vector3 result;
34301
34302   arg1 = (Dali::Actor *)jarg1;
34303   {
34304     try {
34305       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34306     } catch (std::out_of_range& e) {
34307       {
34308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34309       };
34310     } catch (std::exception& e) {
34311       {
34312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34313       };
34314     } catch (Dali::DaliException e) {
34315       {
34316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34317       };
34318     } catch (...) {
34319       {
34320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34321       };
34322     }
34323   }
34324
34325   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34326   return jresult;
34327 }
34328
34329
34330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34331   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34332   float arg2 ;
34333   float arg3 ;
34334
34335   arg1 = (Dali::Actor *)jarg1;
34336   arg2 = (float)jarg2;
34337   arg3 = (float)jarg3;
34338   {
34339     try {
34340       (arg1)->SetSize(arg2,arg3);
34341     } catch (std::out_of_range& e) {
34342       {
34343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34344       };
34345     } catch (std::exception& e) {
34346       {
34347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34348       };
34349     } catch (Dali::DaliException e) {
34350       {
34351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34352       };
34353     } catch (...) {
34354       {
34355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34356       };
34357     }
34358   }
34359
34360 }
34361
34362
34363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34364   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34365   float arg2 ;
34366   float arg3 ;
34367   float arg4 ;
34368
34369   arg1 = (Dali::Actor *)jarg1;
34370   arg2 = (float)jarg2;
34371   arg3 = (float)jarg3;
34372   arg4 = (float)jarg4;
34373   {
34374     try {
34375       (arg1)->SetSize(arg2,arg3,arg4);
34376     } catch (std::out_of_range& e) {
34377       {
34378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34379       };
34380     } catch (std::exception& e) {
34381       {
34382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34383       };
34384     } catch (Dali::DaliException e) {
34385       {
34386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34387       };
34388     } catch (...) {
34389       {
34390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34391       };
34392     }
34393   }
34394
34395 }
34396
34397
34398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34399   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34400   Dali::Vector2 *arg2 = 0 ;
34401
34402   arg1 = (Dali::Actor *)jarg1;
34403   arg2 = (Dali::Vector2 *)jarg2;
34404   if (!arg2) {
34405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34406     return ;
34407   }
34408   {
34409     try {
34410       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34411     } catch (std::out_of_range& e) {
34412       {
34413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34414       };
34415     } catch (std::exception& e) {
34416       {
34417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34418       };
34419     } catch (Dali::DaliException e) {
34420       {
34421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34422       };
34423     } catch (...) {
34424       {
34425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34426       };
34427     }
34428   }
34429
34430 }
34431
34432
34433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34434   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34435   Dali::Vector3 *arg2 = 0 ;
34436
34437   arg1 = (Dali::Actor *)jarg1;
34438   arg2 = (Dali::Vector3 *)jarg2;
34439   if (!arg2) {
34440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34441     return ;
34442   }
34443   {
34444     try {
34445       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34446     } catch (std::out_of_range& e) {
34447       {
34448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34449       };
34450     } catch (std::exception& e) {
34451       {
34452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34453       };
34454     } catch (Dali::DaliException e) {
34455       {
34456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34457       };
34458     } catch (...) {
34459       {
34460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34461       };
34462     }
34463   }
34464
34465 }
34466
34467
34468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34469   void * jresult ;
34470   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34471   Dali::Vector3 result;
34472
34473   arg1 = (Dali::Actor *)jarg1;
34474   {
34475     try {
34476       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34477     } catch (std::out_of_range& e) {
34478       {
34479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34480       };
34481     } catch (std::exception& e) {
34482       {
34483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34484       };
34485     } catch (Dali::DaliException e) {
34486       {
34487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34488       };
34489     } catch (...) {
34490       {
34491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34492       };
34493     }
34494   }
34495
34496   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34497   return jresult;
34498 }
34499
34500
34501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34502   void * jresult ;
34503   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34504   Dali::Vector3 result;
34505
34506   arg1 = (Dali::Actor *)jarg1;
34507   {
34508     try {
34509       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34510     } catch (std::out_of_range& e) {
34511       {
34512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34513       };
34514     } catch (std::exception& e) {
34515       {
34516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34517       };
34518     } catch (Dali::DaliException e) {
34519       {
34520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34521       };
34522     } catch (...) {
34523       {
34524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34525       };
34526     }
34527   }
34528
34529   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34530   return jresult;
34531 }
34532
34533
34534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34535   void * jresult ;
34536   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34537   Dali::Vector3 result;
34538
34539   arg1 = (Dali::Actor *)jarg1;
34540   {
34541     try {
34542       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34543     } catch (std::out_of_range& e) {
34544       {
34545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34546       };
34547     } catch (std::exception& e) {
34548       {
34549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34550       };
34551     } catch (Dali::DaliException e) {
34552       {
34553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34554       };
34555     } catch (...) {
34556       {
34557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34558       };
34559     }
34560   }
34561
34562   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34563   return jresult;
34564 }
34565
34566
34567 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34568   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34569   float arg2 ;
34570   float arg3 ;
34571
34572   arg1 = (Dali::Actor *)jarg1;
34573   arg2 = (float)jarg2;
34574   arg3 = (float)jarg3;
34575   {
34576     try {
34577       (arg1)->SetPosition(arg2,arg3);
34578     } catch (std::out_of_range& e) {
34579       {
34580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34581       };
34582     } catch (std::exception& e) {
34583       {
34584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34585       };
34586     } catch (Dali::DaliException e) {
34587       {
34588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34589       };
34590     } catch (...) {
34591       {
34592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34593       };
34594     }
34595   }
34596
34597 }
34598
34599
34600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34601   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34602   float arg2 ;
34603   float arg3 ;
34604   float arg4 ;
34605
34606   arg1 = (Dali::Actor *)jarg1;
34607   arg2 = (float)jarg2;
34608   arg3 = (float)jarg3;
34609   arg4 = (float)jarg4;
34610   {
34611     try {
34612       (arg1)->SetPosition(arg2,arg3,arg4);
34613     } catch (std::out_of_range& e) {
34614       {
34615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34616       };
34617     } catch (std::exception& e) {
34618       {
34619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34620       };
34621     } catch (Dali::DaliException e) {
34622       {
34623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34624       };
34625     } catch (...) {
34626       {
34627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34628       };
34629     }
34630   }
34631
34632 }
34633
34634
34635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34636   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34637   Dali::Vector3 *arg2 = 0 ;
34638
34639   arg1 = (Dali::Actor *)jarg1;
34640   arg2 = (Dali::Vector3 *)jarg2;
34641   if (!arg2) {
34642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34643     return ;
34644   }
34645   {
34646     try {
34647       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34648     } catch (std::out_of_range& e) {
34649       {
34650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34651       };
34652     } catch (std::exception& e) {
34653       {
34654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34655       };
34656     } catch (Dali::DaliException e) {
34657       {
34658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34659       };
34660     } catch (...) {
34661       {
34662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34663       };
34664     }
34665   }
34666
34667 }
34668
34669
34670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34671   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34672   float arg2 ;
34673
34674   arg1 = (Dali::Actor *)jarg1;
34675   arg2 = (float)jarg2;
34676   {
34677     try {
34678       (arg1)->SetX(arg2);
34679     } catch (std::out_of_range& e) {
34680       {
34681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34682       };
34683     } catch (std::exception& e) {
34684       {
34685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34686       };
34687     } catch (Dali::DaliException e) {
34688       {
34689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34690       };
34691     } catch (...) {
34692       {
34693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34694       };
34695     }
34696   }
34697
34698 }
34699
34700
34701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34702   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34703   float arg2 ;
34704
34705   arg1 = (Dali::Actor *)jarg1;
34706   arg2 = (float)jarg2;
34707   {
34708     try {
34709       (arg1)->SetY(arg2);
34710     } catch (std::out_of_range& e) {
34711       {
34712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34713       };
34714     } catch (std::exception& e) {
34715       {
34716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34717       };
34718     } catch (Dali::DaliException e) {
34719       {
34720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34721       };
34722     } catch (...) {
34723       {
34724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34725       };
34726     }
34727   }
34728
34729 }
34730
34731
34732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34733   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34734   float arg2 ;
34735
34736   arg1 = (Dali::Actor *)jarg1;
34737   arg2 = (float)jarg2;
34738   {
34739     try {
34740       (arg1)->SetZ(arg2);
34741     } catch (std::out_of_range& e) {
34742       {
34743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34744       };
34745     } catch (std::exception& e) {
34746       {
34747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34748       };
34749     } catch (Dali::DaliException e) {
34750       {
34751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34752       };
34753     } catch (...) {
34754       {
34755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34756       };
34757     }
34758   }
34759
34760 }
34761
34762
34763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34764   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34765   Dali::Vector3 *arg2 = 0 ;
34766
34767   arg1 = (Dali::Actor *)jarg1;
34768   arg2 = (Dali::Vector3 *)jarg2;
34769   if (!arg2) {
34770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34771     return ;
34772   }
34773   {
34774     try {
34775       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34776     } catch (std::out_of_range& e) {
34777       {
34778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34779       };
34780     } catch (std::exception& e) {
34781       {
34782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34783       };
34784     } catch (Dali::DaliException e) {
34785       {
34786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34787       };
34788     } catch (...) {
34789       {
34790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34791       };
34792     }
34793   }
34794
34795 }
34796
34797
34798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34799   void * jresult ;
34800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34801   Dali::Vector3 result;
34802
34803   arg1 = (Dali::Actor *)jarg1;
34804   {
34805     try {
34806       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34807     } catch (std::out_of_range& e) {
34808       {
34809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34810       };
34811     } catch (std::exception& e) {
34812       {
34813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34814       };
34815     } catch (Dali::DaliException e) {
34816       {
34817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34818       };
34819     } catch (...) {
34820       {
34821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34822       };
34823     }
34824   }
34825
34826   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34827   return jresult;
34828 }
34829
34830
34831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34832   void * jresult ;
34833   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34834   Dali::Vector3 result;
34835
34836   arg1 = (Dali::Actor *)jarg1;
34837   {
34838     try {
34839       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34840     } catch (std::out_of_range& e) {
34841       {
34842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34843       };
34844     } catch (std::exception& e) {
34845       {
34846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34847       };
34848     } catch (Dali::DaliException e) {
34849       {
34850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34851       };
34852     } catch (...) {
34853       {
34854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34855       };
34856     }
34857   }
34858
34859   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34860   return jresult;
34861 }
34862
34863
34864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34865   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34866   bool arg2 ;
34867
34868   arg1 = (Dali::Actor *)jarg1;
34869   arg2 = jarg2 ? true : false;
34870   {
34871     try {
34872       (arg1)->SetInheritPosition(arg2);
34873     } catch (std::out_of_range& e) {
34874       {
34875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34876       };
34877     } catch (std::exception& e) {
34878       {
34879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34880       };
34881     } catch (Dali::DaliException e) {
34882       {
34883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34884       };
34885     } catch (...) {
34886       {
34887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34888       };
34889     }
34890   }
34891
34892 }
34893
34894
34895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34896   unsigned int jresult ;
34897   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34898   bool result;
34899
34900   arg1 = (Dali::Actor *)jarg1;
34901   {
34902     try {
34903       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34904     } catch (std::out_of_range& e) {
34905       {
34906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34907       };
34908     } catch (std::exception& e) {
34909       {
34910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34911       };
34912     } catch (Dali::DaliException e) {
34913       {
34914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34915       };
34916     } catch (...) {
34917       {
34918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34919       };
34920     }
34921   }
34922
34923   jresult = result;
34924   return jresult;
34925 }
34926
34927
34928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34930   Dali::Degree *arg2 = 0 ;
34931   Dali::Vector3 *arg3 = 0 ;
34932
34933   arg1 = (Dali::Actor *)jarg1;
34934   arg2 = (Dali::Degree *)jarg2;
34935   if (!arg2) {
34936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34937     return ;
34938   }
34939   arg3 = (Dali::Vector3 *)jarg3;
34940   if (!arg3) {
34941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34942     return ;
34943   }
34944   {
34945     try {
34946       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34947     } catch (std::out_of_range& e) {
34948       {
34949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34950       };
34951     } catch (std::exception& e) {
34952       {
34953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34954       };
34955     } catch (Dali::DaliException e) {
34956       {
34957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34958       };
34959     } catch (...) {
34960       {
34961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34962       };
34963     }
34964   }
34965
34966 }
34967
34968
34969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34970   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34971   Dali::Radian *arg2 = 0 ;
34972   Dali::Vector3 *arg3 = 0 ;
34973
34974   arg1 = (Dali::Actor *)jarg1;
34975   arg2 = (Dali::Radian *)jarg2;
34976   if (!arg2) {
34977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34978     return ;
34979   }
34980   arg3 = (Dali::Vector3 *)jarg3;
34981   if (!arg3) {
34982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34983     return ;
34984   }
34985   {
34986     try {
34987       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34988     } catch (std::out_of_range& e) {
34989       {
34990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34991       };
34992     } catch (std::exception& e) {
34993       {
34994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34995       };
34996     } catch (Dali::DaliException e) {
34997       {
34998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34999       };
35000     } catch (...) {
35001       {
35002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35003       };
35004     }
35005   }
35006
35007 }
35008
35009
35010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35012   Dali::Quaternion *arg2 = 0 ;
35013
35014   arg1 = (Dali::Actor *)jarg1;
35015   arg2 = (Dali::Quaternion *)jarg2;
35016   if (!arg2) {
35017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35018     return ;
35019   }
35020   {
35021     try {
35022       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
35023     } catch (std::out_of_range& e) {
35024       {
35025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35026       };
35027     } catch (std::exception& e) {
35028       {
35029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35030       };
35031     } catch (Dali::DaliException e) {
35032       {
35033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35034       };
35035     } catch (...) {
35036       {
35037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35038       };
35039     }
35040   }
35041
35042 }
35043
35044
35045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35047   Dali::Degree *arg2 = 0 ;
35048   Dali::Vector3 *arg3 = 0 ;
35049
35050   arg1 = (Dali::Actor *)jarg1;
35051   arg2 = (Dali::Degree *)jarg2;
35052   if (!arg2) {
35053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35054     return ;
35055   }
35056   arg3 = (Dali::Vector3 *)jarg3;
35057   if (!arg3) {
35058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35059     return ;
35060   }
35061   {
35062     try {
35063       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35064     } catch (std::out_of_range& e) {
35065       {
35066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35067       };
35068     } catch (std::exception& e) {
35069       {
35070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35071       };
35072     } catch (Dali::DaliException e) {
35073       {
35074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35075       };
35076     } catch (...) {
35077       {
35078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35079       };
35080     }
35081   }
35082
35083 }
35084
35085
35086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35087   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35088   Dali::Radian *arg2 = 0 ;
35089   Dali::Vector3 *arg3 = 0 ;
35090
35091   arg1 = (Dali::Actor *)jarg1;
35092   arg2 = (Dali::Radian *)jarg2;
35093   if (!arg2) {
35094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35095     return ;
35096   }
35097   arg3 = (Dali::Vector3 *)jarg3;
35098   if (!arg3) {
35099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35100     return ;
35101   }
35102   {
35103     try {
35104       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35105     } catch (std::out_of_range& e) {
35106       {
35107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35108       };
35109     } catch (std::exception& e) {
35110       {
35111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35112       };
35113     } catch (Dali::DaliException e) {
35114       {
35115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35116       };
35117     } catch (...) {
35118       {
35119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35120       };
35121     }
35122   }
35123
35124 }
35125
35126
35127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35128   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35129   Dali::Quaternion *arg2 = 0 ;
35130
35131   arg1 = (Dali::Actor *)jarg1;
35132   arg2 = (Dali::Quaternion *)jarg2;
35133   if (!arg2) {
35134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35135     return ;
35136   }
35137   {
35138     try {
35139       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35140     } catch (std::out_of_range& e) {
35141       {
35142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35143       };
35144     } catch (std::exception& e) {
35145       {
35146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35147       };
35148     } catch (Dali::DaliException e) {
35149       {
35150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35151       };
35152     } catch (...) {
35153       {
35154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35155       };
35156     }
35157   }
35158
35159 }
35160
35161
35162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35163   void * jresult ;
35164   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35165   Dali::Quaternion result;
35166
35167   arg1 = (Dali::Actor *)jarg1;
35168   {
35169     try {
35170       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35171     } catch (std::out_of_range& e) {
35172       {
35173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35174       };
35175     } catch (std::exception& e) {
35176       {
35177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35178       };
35179     } catch (Dali::DaliException e) {
35180       {
35181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35182       };
35183     } catch (...) {
35184       {
35185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35186       };
35187     }
35188   }
35189
35190   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35191   return jresult;
35192 }
35193
35194
35195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35196   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35197   bool arg2 ;
35198
35199   arg1 = (Dali::Actor *)jarg1;
35200   arg2 = jarg2 ? true : false;
35201   {
35202     try {
35203       (arg1)->SetInheritOrientation(arg2);
35204     } catch (std::out_of_range& e) {
35205       {
35206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35207       };
35208     } catch (std::exception& e) {
35209       {
35210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35211       };
35212     } catch (Dali::DaliException e) {
35213       {
35214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35215       };
35216     } catch (...) {
35217       {
35218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35219       };
35220     }
35221   }
35222
35223 }
35224
35225
35226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35227   unsigned int jresult ;
35228   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35229   bool result;
35230
35231   arg1 = (Dali::Actor *)jarg1;
35232   {
35233     try {
35234       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35235     } catch (std::out_of_range& e) {
35236       {
35237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35238       };
35239     } catch (std::exception& e) {
35240       {
35241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35242       };
35243     } catch (Dali::DaliException e) {
35244       {
35245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35246       };
35247     } catch (...) {
35248       {
35249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35250       };
35251     }
35252   }
35253
35254   jresult = result;
35255   return jresult;
35256 }
35257
35258
35259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35260   void * jresult ;
35261   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35262   Dali::Quaternion result;
35263
35264   arg1 = (Dali::Actor *)jarg1;
35265   {
35266     try {
35267       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35268     } catch (std::out_of_range& e) {
35269       {
35270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35271       };
35272     } catch (std::exception& e) {
35273       {
35274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35275       };
35276     } catch (Dali::DaliException e) {
35277       {
35278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35279       };
35280     } catch (...) {
35281       {
35282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35283       };
35284     }
35285   }
35286
35287   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35288   return jresult;
35289 }
35290
35291
35292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35294   float arg2 ;
35295
35296   arg1 = (Dali::Actor *)jarg1;
35297   arg2 = (float)jarg2;
35298   {
35299     try {
35300       (arg1)->SetScale(arg2);
35301     } catch (std::out_of_range& e) {
35302       {
35303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35304       };
35305     } catch (std::exception& e) {
35306       {
35307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35308       };
35309     } catch (Dali::DaliException e) {
35310       {
35311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35312       };
35313     } catch (...) {
35314       {
35315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35316       };
35317     }
35318   }
35319
35320 }
35321
35322
35323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35325   float arg2 ;
35326   float arg3 ;
35327   float arg4 ;
35328
35329   arg1 = (Dali::Actor *)jarg1;
35330   arg2 = (float)jarg2;
35331   arg3 = (float)jarg3;
35332   arg4 = (float)jarg4;
35333   {
35334     try {
35335       (arg1)->SetScale(arg2,arg3,arg4);
35336     } catch (std::out_of_range& e) {
35337       {
35338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35339       };
35340     } catch (std::exception& e) {
35341       {
35342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35343       };
35344     } catch (Dali::DaliException e) {
35345       {
35346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35347       };
35348     } catch (...) {
35349       {
35350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35351       };
35352     }
35353   }
35354
35355 }
35356
35357
35358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35359   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35360   Dali::Vector3 *arg2 = 0 ;
35361
35362   arg1 = (Dali::Actor *)jarg1;
35363   arg2 = (Dali::Vector3 *)jarg2;
35364   if (!arg2) {
35365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35366     return ;
35367   }
35368   {
35369     try {
35370       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35371     } catch (std::out_of_range& e) {
35372       {
35373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35374       };
35375     } catch (std::exception& e) {
35376       {
35377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35378       };
35379     } catch (Dali::DaliException e) {
35380       {
35381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35382       };
35383     } catch (...) {
35384       {
35385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35386       };
35387     }
35388   }
35389
35390 }
35391
35392
35393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35394   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35395   Dali::Vector3 *arg2 = 0 ;
35396
35397   arg1 = (Dali::Actor *)jarg1;
35398   arg2 = (Dali::Vector3 *)jarg2;
35399   if (!arg2) {
35400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35401     return ;
35402   }
35403   {
35404     try {
35405       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35406     } catch (std::out_of_range& e) {
35407       {
35408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35409       };
35410     } catch (std::exception& e) {
35411       {
35412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35413       };
35414     } catch (Dali::DaliException e) {
35415       {
35416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35417       };
35418     } catch (...) {
35419       {
35420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35421       };
35422     }
35423   }
35424
35425 }
35426
35427
35428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35429   void * jresult ;
35430   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35431   Dali::Vector3 result;
35432
35433   arg1 = (Dali::Actor *)jarg1;
35434   {
35435     try {
35436       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35437     } catch (std::out_of_range& e) {
35438       {
35439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35440       };
35441     } catch (std::exception& e) {
35442       {
35443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35444       };
35445     } catch (Dali::DaliException e) {
35446       {
35447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35448       };
35449     } catch (...) {
35450       {
35451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35452       };
35453     }
35454   }
35455
35456   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35457   return jresult;
35458 }
35459
35460
35461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35462   void * jresult ;
35463   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35464   Dali::Vector3 result;
35465
35466   arg1 = (Dali::Actor *)jarg1;
35467   {
35468     try {
35469       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35470     } catch (std::out_of_range& e) {
35471       {
35472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35473       };
35474     } catch (std::exception& e) {
35475       {
35476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35477       };
35478     } catch (Dali::DaliException e) {
35479       {
35480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35481       };
35482     } catch (...) {
35483       {
35484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35485       };
35486     }
35487   }
35488
35489   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35490   return jresult;
35491 }
35492
35493
35494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35495   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35496   bool arg2 ;
35497
35498   arg1 = (Dali::Actor *)jarg1;
35499   arg2 = jarg2 ? true : false;
35500   {
35501     try {
35502       (arg1)->SetInheritScale(arg2);
35503     } catch (std::out_of_range& e) {
35504       {
35505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35506       };
35507     } catch (std::exception& e) {
35508       {
35509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35510       };
35511     } catch (Dali::DaliException e) {
35512       {
35513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35514       };
35515     } catch (...) {
35516       {
35517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35518       };
35519     }
35520   }
35521
35522 }
35523
35524
35525 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35526   unsigned int jresult ;
35527   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35528   bool result;
35529
35530   arg1 = (Dali::Actor *)jarg1;
35531   {
35532     try {
35533       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35534     } catch (std::out_of_range& e) {
35535       {
35536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35537       };
35538     } catch (std::exception& e) {
35539       {
35540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35541       };
35542     } catch (Dali::DaliException e) {
35543       {
35544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35545       };
35546     } catch (...) {
35547       {
35548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35549       };
35550     }
35551   }
35552
35553   jresult = result;
35554   return jresult;
35555 }
35556
35557
35558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35559   void * jresult ;
35560   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35561   Dali::Matrix result;
35562
35563   arg1 = (Dali::Actor *)jarg1;
35564   {
35565     try {
35566       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35567     } catch (std::out_of_range& e) {
35568       {
35569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35570       };
35571     } catch (std::exception& e) {
35572       {
35573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35574       };
35575     } catch (Dali::DaliException e) {
35576       {
35577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35578       };
35579     } catch (...) {
35580       {
35581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35582       };
35583     }
35584   }
35585
35586   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35587   return jresult;
35588 }
35589
35590
35591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35593   bool arg2 ;
35594
35595   arg1 = (Dali::Actor *)jarg1;
35596   arg2 = jarg2 ? true : false;
35597   {
35598     try {
35599       (arg1)->SetVisible(arg2);
35600     } catch (std::out_of_range& e) {
35601       {
35602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35603       };
35604     } catch (std::exception& e) {
35605       {
35606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35607       };
35608     } catch (Dali::DaliException e) {
35609       {
35610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35611       };
35612     } catch (...) {
35613       {
35614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35615       };
35616     }
35617   }
35618
35619 }
35620
35621
35622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35623   unsigned int jresult ;
35624   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35625   bool result;
35626
35627   arg1 = (Dali::Actor *)jarg1;
35628   {
35629     try {
35630       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35631     } catch (std::out_of_range& e) {
35632       {
35633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35634       };
35635     } catch (std::exception& e) {
35636       {
35637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35638       };
35639     } catch (Dali::DaliException e) {
35640       {
35641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35642       };
35643     } catch (...) {
35644       {
35645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35646       };
35647     }
35648   }
35649
35650   jresult = result;
35651   return jresult;
35652 }
35653
35654
35655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35657   float arg2 ;
35658
35659   arg1 = (Dali::Actor *)jarg1;
35660   arg2 = (float)jarg2;
35661   {
35662     try {
35663       (arg1)->SetOpacity(arg2);
35664     } catch (std::out_of_range& e) {
35665       {
35666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35667       };
35668     } catch (std::exception& e) {
35669       {
35670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35671       };
35672     } catch (Dali::DaliException e) {
35673       {
35674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35675       };
35676     } catch (...) {
35677       {
35678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35679       };
35680     }
35681   }
35682
35683 }
35684
35685
35686 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35687   float jresult ;
35688   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35689   float result;
35690
35691   arg1 = (Dali::Actor *)jarg1;
35692   {
35693     try {
35694       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35695     } catch (std::out_of_range& e) {
35696       {
35697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35698       };
35699     } catch (std::exception& e) {
35700       {
35701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35702       };
35703     } catch (Dali::DaliException e) {
35704       {
35705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35706       };
35707     } catch (...) {
35708       {
35709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35710       };
35711     }
35712   }
35713
35714   jresult = result;
35715   return jresult;
35716 }
35717
35718
35719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35721   Dali::Vector4 *arg2 = 0 ;
35722
35723   arg1 = (Dali::Actor *)jarg1;
35724   arg2 = (Dali::Vector4 *)jarg2;
35725   if (!arg2) {
35726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35727     return ;
35728   }
35729   {
35730     try {
35731       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35732     } catch (std::out_of_range& e) {
35733       {
35734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35735       };
35736     } catch (std::exception& e) {
35737       {
35738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35739       };
35740     } catch (Dali::DaliException e) {
35741       {
35742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35743       };
35744     } catch (...) {
35745       {
35746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35747       };
35748     }
35749   }
35750
35751 }
35752
35753
35754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35755   void * jresult ;
35756   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35757   Dali::Vector4 result;
35758
35759   arg1 = (Dali::Actor *)jarg1;
35760   {
35761     try {
35762       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35763     } catch (std::out_of_range& e) {
35764       {
35765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35766       };
35767     } catch (std::exception& e) {
35768       {
35769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35770       };
35771     } catch (Dali::DaliException e) {
35772       {
35773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35774       };
35775     } catch (...) {
35776       {
35777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35778       };
35779     }
35780   }
35781
35782   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35783   return jresult;
35784 }
35785
35786
35787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35788   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35789   Dali::ColorMode arg2 ;
35790
35791   arg1 = (Dali::Actor *)jarg1;
35792   arg2 = (Dali::ColorMode)jarg2;
35793   {
35794     try {
35795       (arg1)->SetColorMode(arg2);
35796     } catch (std::out_of_range& e) {
35797       {
35798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35799       };
35800     } catch (std::exception& e) {
35801       {
35802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35803       };
35804     } catch (Dali::DaliException e) {
35805       {
35806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35807       };
35808     } catch (...) {
35809       {
35810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35811       };
35812     }
35813   }
35814
35815 }
35816
35817
35818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35819   int jresult ;
35820   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35821   Dali::ColorMode result;
35822
35823   arg1 = (Dali::Actor *)jarg1;
35824   {
35825     try {
35826       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35827     } catch (std::out_of_range& e) {
35828       {
35829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35830       };
35831     } catch (std::exception& e) {
35832       {
35833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35834       };
35835     } catch (Dali::DaliException e) {
35836       {
35837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35838       };
35839     } catch (...) {
35840       {
35841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35842       };
35843     }
35844   }
35845
35846   jresult = (int)result;
35847   return jresult;
35848 }
35849
35850
35851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35852   void * jresult ;
35853   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35854   Dali::Vector4 result;
35855
35856   arg1 = (Dali::Actor *)jarg1;
35857   {
35858     try {
35859       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35860     } catch (std::out_of_range& e) {
35861       {
35862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35863       };
35864     } catch (std::exception& e) {
35865       {
35866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35867       };
35868     } catch (Dali::DaliException e) {
35869       {
35870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35871       };
35872     } catch (...) {
35873       {
35874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35875       };
35876     }
35877   }
35878
35879   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35880   return jresult;
35881 }
35882
35883
35884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35886   Dali::DrawMode::Type arg2 ;
35887
35888   arg1 = (Dali::Actor *)jarg1;
35889   arg2 = (Dali::DrawMode::Type)jarg2;
35890   {
35891     try {
35892       (arg1)->SetDrawMode(arg2);
35893     } catch (std::out_of_range& e) {
35894       {
35895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35896       };
35897     } catch (std::exception& e) {
35898       {
35899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35900       };
35901     } catch (Dali::DaliException e) {
35902       {
35903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35904       };
35905     } catch (...) {
35906       {
35907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35908       };
35909     }
35910   }
35911
35912 }
35913
35914
35915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35916   int jresult ;
35917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35918   Dali::DrawMode::Type result;
35919
35920   arg1 = (Dali::Actor *)jarg1;
35921   {
35922     try {
35923       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35924     } catch (std::out_of_range& e) {
35925       {
35926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35927       };
35928     } catch (std::exception& e) {
35929       {
35930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35931       };
35932     } catch (Dali::DaliException e) {
35933       {
35934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35935       };
35936     } catch (...) {
35937       {
35938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35939       };
35940     }
35941   }
35942
35943   jresult = (int)result;
35944   return jresult;
35945 }
35946
35947
35948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35950   bool arg2 ;
35951
35952   arg1 = (Dali::Actor *)jarg1;
35953   arg2 = jarg2 ? true : false;
35954   {
35955     try {
35956       (arg1)->SetSensitive(arg2);
35957     } catch (std::out_of_range& e) {
35958       {
35959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35960       };
35961     } catch (std::exception& e) {
35962       {
35963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35964       };
35965     } catch (Dali::DaliException e) {
35966       {
35967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35968       };
35969     } catch (...) {
35970       {
35971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35972       };
35973     }
35974   }
35975
35976 }
35977
35978
35979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35980   unsigned int jresult ;
35981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35982   bool result;
35983
35984   arg1 = (Dali::Actor *)jarg1;
35985   {
35986     try {
35987       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35988     } catch (std::out_of_range& e) {
35989       {
35990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35991       };
35992     } catch (std::exception& e) {
35993       {
35994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35995       };
35996     } catch (Dali::DaliException e) {
35997       {
35998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35999       };
36000     } catch (...) {
36001       {
36002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36003       };
36004     }
36005   }
36006
36007   jresult = result;
36008   return jresult;
36009 }
36010
36011
36012 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36013   unsigned int jresult ;
36014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36015   float *arg2 = 0 ;
36016   float *arg3 = 0 ;
36017   float arg4 ;
36018   float arg5 ;
36019   bool result;
36020
36021   arg1 = (Dali::Actor *)jarg1;
36022   arg2 = (float *)jarg2;
36023   arg3 = (float *)jarg3;
36024   arg4 = (float)jarg4;
36025   arg5 = (float)jarg5;
36026   {
36027     try {
36028       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36029     } catch (std::out_of_range& e) {
36030       {
36031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36032       };
36033     } catch (std::exception& e) {
36034       {
36035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36036       };
36037     } catch (Dali::DaliException e) {
36038       {
36039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36040       };
36041     } catch (...) {
36042       {
36043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36044       };
36045     }
36046   }
36047
36048   jresult = result;
36049   return jresult;
36050 }
36051
36052
36053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36054   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36055   bool arg2 ;
36056
36057   arg1 = (Dali::Actor *)jarg1;
36058   arg2 = jarg2 ? true : false;
36059   {
36060     try {
36061       (arg1)->SetLeaveRequired(arg2);
36062     } catch (std::out_of_range& e) {
36063       {
36064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36065       };
36066     } catch (std::exception& e) {
36067       {
36068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36069       };
36070     } catch (Dali::DaliException e) {
36071       {
36072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36073       };
36074     } catch (...) {
36075       {
36076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36077       };
36078     }
36079   }
36080
36081 }
36082
36083
36084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36085   unsigned int jresult ;
36086   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36087   bool result;
36088
36089   arg1 = (Dali::Actor *)jarg1;
36090   {
36091     try {
36092       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36093     } catch (std::out_of_range& e) {
36094       {
36095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36096       };
36097     } catch (std::exception& e) {
36098       {
36099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36100       };
36101     } catch (Dali::DaliException e) {
36102       {
36103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36104       };
36105     } catch (...) {
36106       {
36107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36108       };
36109     }
36110   }
36111
36112   jresult = result;
36113   return jresult;
36114 }
36115
36116
36117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36118   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36119   bool arg2 ;
36120
36121   arg1 = (Dali::Actor *)jarg1;
36122   arg2 = jarg2 ? true : false;
36123   {
36124     try {
36125       (arg1)->SetKeyboardFocusable(arg2);
36126     } catch (std::out_of_range& e) {
36127       {
36128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36129       };
36130     } catch (std::exception& e) {
36131       {
36132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36133       };
36134     } catch (Dali::DaliException e) {
36135       {
36136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36137       };
36138     } catch (...) {
36139       {
36140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36141       };
36142     }
36143   }
36144
36145 }
36146
36147
36148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36149   unsigned int jresult ;
36150   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36151   bool result;
36152
36153   arg1 = (Dali::Actor *)jarg1;
36154   {
36155     try {
36156       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36157     } catch (std::out_of_range& e) {
36158       {
36159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36160       };
36161     } catch (std::exception& e) {
36162       {
36163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36164       };
36165     } catch (Dali::DaliException e) {
36166       {
36167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36168       };
36169     } catch (...) {
36170       {
36171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36172       };
36173     }
36174   }
36175
36176   jresult = result;
36177   return jresult;
36178 }
36179
36180
36181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36182   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36183   Dali::ResizePolicy::Type arg2 ;
36184   Dali::Dimension::Type arg3 ;
36185
36186   arg1 = (Dali::Actor *)jarg1;
36187   arg2 = (Dali::ResizePolicy::Type)jarg2;
36188   arg3 = (Dali::Dimension::Type)jarg3;
36189   {
36190     try {
36191       (arg1)->SetResizePolicy(arg2,arg3);
36192     } catch (std::out_of_range& e) {
36193       {
36194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36195       };
36196     } catch (std::exception& e) {
36197       {
36198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36199       };
36200     } catch (Dali::DaliException e) {
36201       {
36202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36203       };
36204     } catch (...) {
36205       {
36206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36207       };
36208     }
36209   }
36210
36211 }
36212
36213
36214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36215   int jresult ;
36216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36217   Dali::Dimension::Type arg2 ;
36218   Dali::ResizePolicy::Type result;
36219
36220   arg1 = (Dali::Actor *)jarg1;
36221   arg2 = (Dali::Dimension::Type)jarg2;
36222   {
36223     try {
36224       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36225     } catch (std::out_of_range& e) {
36226       {
36227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36228       };
36229     } catch (std::exception& e) {
36230       {
36231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36232       };
36233     } catch (Dali::DaliException e) {
36234       {
36235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36236       };
36237     } catch (...) {
36238       {
36239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36240       };
36241     }
36242   }
36243
36244   jresult = (int)result;
36245   return jresult;
36246 }
36247
36248
36249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36250   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36251   Dali::SizeScalePolicy::Type arg2 ;
36252
36253   arg1 = (Dali::Actor *)jarg1;
36254   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36255   {
36256     try {
36257       (arg1)->SetSizeScalePolicy(arg2);
36258     } catch (std::out_of_range& e) {
36259       {
36260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36261       };
36262     } catch (std::exception& e) {
36263       {
36264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36265       };
36266     } catch (Dali::DaliException e) {
36267       {
36268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36269       };
36270     } catch (...) {
36271       {
36272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36273       };
36274     }
36275   }
36276
36277 }
36278
36279
36280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36281   int jresult ;
36282   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36283   Dali::SizeScalePolicy::Type result;
36284
36285   arg1 = (Dali::Actor *)jarg1;
36286   {
36287     try {
36288       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36289     } catch (std::out_of_range& e) {
36290       {
36291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36292       };
36293     } catch (std::exception& e) {
36294       {
36295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36296       };
36297     } catch (Dali::DaliException e) {
36298       {
36299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36300       };
36301     } catch (...) {
36302       {
36303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36304       };
36305     }
36306   }
36307
36308   jresult = (int)result;
36309   return jresult;
36310 }
36311
36312
36313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36314   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36315   Dali::Vector3 *arg2 = 0 ;
36316
36317   arg1 = (Dali::Actor *)jarg1;
36318   arg2 = (Dali::Vector3 *)jarg2;
36319   if (!arg2) {
36320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36321     return ;
36322   }
36323   {
36324     try {
36325       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36326     } catch (std::out_of_range& e) {
36327       {
36328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36329       };
36330     } catch (std::exception& e) {
36331       {
36332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36333       };
36334     } catch (Dali::DaliException e) {
36335       {
36336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36337       };
36338     } catch (...) {
36339       {
36340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36341       };
36342     }
36343   }
36344
36345 }
36346
36347
36348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36349   void * jresult ;
36350   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36351   Dali::Vector3 result;
36352
36353   arg1 = (Dali::Actor *)jarg1;
36354   {
36355     try {
36356       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36357     } catch (std::out_of_range& e) {
36358       {
36359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (std::exception& e) {
36362       {
36363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36364       };
36365     } catch (Dali::DaliException e) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36368       };
36369     } catch (...) {
36370       {
36371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36372       };
36373     }
36374   }
36375
36376   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36377   return jresult;
36378 }
36379
36380
36381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36382   float jresult ;
36383   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36384   float arg2 ;
36385   float result;
36386
36387   arg1 = (Dali::Actor *)jarg1;
36388   arg2 = (float)jarg2;
36389   {
36390     try {
36391       result = (float)(arg1)->GetHeightForWidth(arg2);
36392     } catch (std::out_of_range& e) {
36393       {
36394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (std::exception& e) {
36397       {
36398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36399       };
36400     } catch (Dali::DaliException e) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36403       };
36404     } catch (...) {
36405       {
36406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36407       };
36408     }
36409   }
36410
36411   jresult = result;
36412   return jresult;
36413 }
36414
36415
36416 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36417   float jresult ;
36418   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36419   float arg2 ;
36420   float result;
36421
36422   arg1 = (Dali::Actor *)jarg1;
36423   arg2 = (float)jarg2;
36424   {
36425     try {
36426       result = (float)(arg1)->GetWidthForHeight(arg2);
36427     } catch (std::out_of_range& e) {
36428       {
36429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36430       };
36431     } catch (std::exception& e) {
36432       {
36433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36434       };
36435     } catch (Dali::DaliException e) {
36436       {
36437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36438       };
36439     } catch (...) {
36440       {
36441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36442       };
36443     }
36444   }
36445
36446   jresult = result;
36447   return jresult;
36448 }
36449
36450
36451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36452   float jresult ;
36453   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36454   Dali::Dimension::Type arg2 ;
36455   float result;
36456
36457   arg1 = (Dali::Actor *)jarg1;
36458   arg2 = (Dali::Dimension::Type)jarg2;
36459   {
36460     try {
36461       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36462     } catch (std::out_of_range& e) {
36463       {
36464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36465       };
36466     } catch (std::exception& e) {
36467       {
36468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36469       };
36470     } catch (Dali::DaliException e) {
36471       {
36472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36473       };
36474     } catch (...) {
36475       {
36476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36477       };
36478     }
36479   }
36480
36481   jresult = result;
36482   return jresult;
36483 }
36484
36485
36486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36487   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36488   Dali::Padding *arg2 = 0 ;
36489
36490   arg1 = (Dali::Actor *)jarg1;
36491   arg2 = (Dali::Padding *)jarg2;
36492   if (!arg2) {
36493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36494     return ;
36495   }
36496   {
36497     try {
36498       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36499     } catch (std::out_of_range& e) {
36500       {
36501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36502       };
36503     } catch (std::exception& e) {
36504       {
36505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36506       };
36507     } catch (Dali::DaliException e) {
36508       {
36509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36510       };
36511     } catch (...) {
36512       {
36513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36514       };
36515     }
36516   }
36517
36518 }
36519
36520
36521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36522   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36523   Dali::Padding *arg2 = 0 ;
36524
36525   arg1 = (Dali::Actor *)jarg1;
36526   arg2 = (Dali::Padding *)jarg2;
36527   if (!arg2) {
36528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36529     return ;
36530   }
36531   {
36532     try {
36533       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36534     } catch (std::out_of_range& e) {
36535       {
36536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36537       };
36538     } catch (std::exception& e) {
36539       {
36540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36541       };
36542     } catch (Dali::DaliException e) {
36543       {
36544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36545       };
36546     } catch (...) {
36547       {
36548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36549       };
36550     }
36551   }
36552
36553 }
36554
36555
36556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36557   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36558   Dali::Vector2 *arg2 = 0 ;
36559
36560   arg1 = (Dali::Actor *)jarg1;
36561   arg2 = (Dali::Vector2 *)jarg2;
36562   if (!arg2) {
36563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36564     return ;
36565   }
36566   {
36567     try {
36568       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36569     } catch (std::out_of_range& e) {
36570       {
36571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36572       };
36573     } catch (std::exception& e) {
36574       {
36575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36576       };
36577     } catch (Dali::DaliException e) {
36578       {
36579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36580       };
36581     } catch (...) {
36582       {
36583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36584       };
36585     }
36586   }
36587
36588 }
36589
36590
36591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36592   void * jresult ;
36593   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36594   Dali::Vector2 result;
36595
36596   arg1 = (Dali::Actor *)jarg1;
36597   {
36598     try {
36599       result = (arg1)->GetMinimumSize();
36600     } catch (std::out_of_range& e) {
36601       {
36602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36603       };
36604     } catch (std::exception& e) {
36605       {
36606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36607       };
36608     } catch (Dali::DaliException e) {
36609       {
36610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36611       };
36612     } catch (...) {
36613       {
36614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36615       };
36616     }
36617   }
36618
36619   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36620   return jresult;
36621 }
36622
36623
36624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36625   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36626   Dali::Vector2 *arg2 = 0 ;
36627
36628   arg1 = (Dali::Actor *)jarg1;
36629   arg2 = (Dali::Vector2 *)jarg2;
36630   if (!arg2) {
36631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36632     return ;
36633   }
36634   {
36635     try {
36636       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36637     } catch (std::out_of_range& e) {
36638       {
36639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36640       };
36641     } catch (std::exception& e) {
36642       {
36643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36644       };
36645     } catch (Dali::DaliException e) {
36646       {
36647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36648       };
36649     } catch (...) {
36650       {
36651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36652       };
36653     }
36654   }
36655
36656 }
36657
36658
36659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36660   void * jresult ;
36661   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36662   Dali::Vector2 result;
36663
36664   arg1 = (Dali::Actor *)jarg1;
36665   {
36666     try {
36667       result = (arg1)->GetMaximumSize();
36668     } catch (std::out_of_range& e) {
36669       {
36670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36671       };
36672     } catch (std::exception& e) {
36673       {
36674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36675       };
36676     } catch (Dali::DaliException e) {
36677       {
36678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36679       };
36680     } catch (...) {
36681       {
36682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36683       };
36684     }
36685   }
36686
36687   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36688   return jresult;
36689 }
36690
36691
36692 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36693   int jresult ;
36694   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36695   int result;
36696
36697   arg1 = (Dali::Actor *)jarg1;
36698   {
36699     try {
36700       result = (int)(arg1)->GetHierarchyDepth();
36701       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
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 unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58784   unsigned int jresult ;
58785   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58786   bool result;
58787
58788   arg1 = (Dali::Signal< bool () > *)jarg1;
58789   {
58790     try {
58791       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58792     } catch (std::out_of_range& e) {
58793       {
58794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58795       };
58796     } catch (std::exception& e) {
58797       {
58798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58799       };
58800     } catch (Dali::DaliException e) {
58801       {
58802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58803       };
58804     } catch (...) {
58805       {
58806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58807       };
58808     }
58809   }
58810
58811   jresult = result;
58812   return jresult;
58813 }
58814
58815
58816 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58817   unsigned long jresult ;
58818   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58819   std::size_t result;
58820
58821   arg1 = (Dali::Signal< bool () > *)jarg1;
58822   {
58823     try {
58824       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58825     } catch (std::out_of_range& e) {
58826       {
58827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58828       };
58829     } catch (std::exception& e) {
58830       {
58831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58832       };
58833     } catch (Dali::DaliException e) {
58834       {
58835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58836       };
58837     } catch (...) {
58838       {
58839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58840       };
58841     }
58842   }
58843
58844   jresult = (unsigned long)result;
58845   return jresult;
58846 }
58847
58848
58849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58850   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58851   bool (*arg2)() = (bool (*)()) 0 ;
58852
58853   arg1 = (Dali::Signal< bool () > *)jarg1;
58854   arg2 = (bool (*)())jarg2;
58855   {
58856     try {
58857       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58858     } catch (std::out_of_range& e) {
58859       {
58860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58861       };
58862     } catch (std::exception& e) {
58863       {
58864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58865       };
58866     } catch (Dali::DaliException e) {
58867       {
58868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58869       };
58870     } catch (...) {
58871       {
58872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58873       };
58874     }
58875   }
58876
58877 }
58878
58879
58880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58881   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58882   bool (*arg2)() = (bool (*)()) 0 ;
58883
58884   arg1 = (Dali::Signal< bool () > *)jarg1;
58885   arg2 = (bool (*)())jarg2;
58886   {
58887     try {
58888       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58889     } catch (std::out_of_range& e) {
58890       {
58891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58892       };
58893     } catch (std::exception& e) {
58894       {
58895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58896       };
58897     } catch (Dali::DaliException e) {
58898       {
58899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58900       };
58901     } catch (...) {
58902       {
58903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58904       };
58905     }
58906   }
58907
58908 }
58909
58910
58911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58912   unsigned int jresult ;
58913   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58914   bool result;
58915
58916   arg1 = (Dali::Signal< bool () > *)jarg1;
58917   {
58918     try {
58919       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58920     } catch (std::out_of_range& e) {
58921       {
58922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58923       };
58924     } catch (std::exception& e) {
58925       {
58926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58927       };
58928     } catch (Dali::DaliException e) {
58929       {
58930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58931       };
58932     } catch (...) {
58933       {
58934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58935       };
58936     }
58937   }
58938
58939   jresult = result;
58940   return jresult;
58941 }
58942
58943
58944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
58945   void * jresult ;
58946   Dali::Signal< bool () > *result = 0 ;
58947
58948   {
58949     try {
58950       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
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_delete_TimerSignalType(void * jarg1) {
58976   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58977
58978   arg1 = (Dali::Signal< bool () > *)jarg1;
58979   {
58980     try {
58981       delete arg1;
58982     } catch (std::out_of_range& e) {
58983       {
58984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58985       };
58986     } catch (std::exception& e) {
58987       {
58988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58989       };
58990     } catch (Dali::DaliException e) {
58991       {
58992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58993       };
58994     } catch (...) {
58995       {
58996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58997       };
58998     }
58999   }
59000
59001 }
59002
59003
59004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
59005   int jresult ;
59006   int result;
59007
59008   {
59009     try {
59010       result = (int)Dali::Toolkit::Visual::Property::TYPE;
59011     } catch (std::out_of_range& e) {
59012       {
59013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59014       };
59015     } catch (std::exception& e) {
59016       {
59017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59018       };
59019     } catch (Dali::DaliException e) {
59020       {
59021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59022       };
59023     } catch (...) {
59024       {
59025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59026       };
59027     }
59028   }
59029
59030   jresult = (int)result;
59031   return jresult;
59032 }
59033
59034
59035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
59036   int jresult ;
59037   int result;
59038
59039   {
59040     try {
59041       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59042     } catch (std::out_of_range& e) {
59043       {
59044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59045       };
59046     } catch (std::exception& e) {
59047       {
59048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59049       };
59050     } catch (Dali::DaliException e) {
59051       {
59052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59053       };
59054     } catch (...) {
59055       {
59056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59057       };
59058     }
59059   }
59060
59061   jresult = (int)result;
59062   return jresult;
59063 }
59064
59065
59066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59067   int jresult ;
59068   int result;
59069
59070   {
59071     try {
59072       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59073     } catch (std::out_of_range& e) {
59074       {
59075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59076       };
59077     } catch (std::exception& e) {
59078       {
59079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59080       };
59081     } catch (Dali::DaliException e) {
59082       {
59083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59084       };
59085     } catch (...) {
59086       {
59087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59088       };
59089     }
59090   }
59091
59092   jresult = (int)result;
59093   return jresult;
59094 }
59095
59096
59097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59098   int jresult ;
59099   int result;
59100
59101   {
59102     try {
59103       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59104     } catch (std::out_of_range& e) {
59105       {
59106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59107       };
59108     } catch (std::exception& e) {
59109       {
59110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59111       };
59112     } catch (Dali::DaliException e) {
59113       {
59114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59115       };
59116     } catch (...) {
59117       {
59118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59119       };
59120     }
59121   }
59122
59123   jresult = (int)result;
59124   return jresult;
59125 }
59126
59127
59128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59129   int jresult ;
59130   int result;
59131
59132   {
59133     try {
59134       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59135     } catch (std::out_of_range& e) {
59136       {
59137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59138       };
59139     } catch (std::exception& e) {
59140       {
59141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59142       };
59143     } catch (Dali::DaliException e) {
59144       {
59145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59146       };
59147     } catch (...) {
59148       {
59149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59150       };
59151     }
59152   }
59153
59154   jresult = (int)result;
59155   return jresult;
59156 }
59157
59158
59159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59160   int jresult ;
59161   int result;
59162
59163   {
59164     try {
59165       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59166     } catch (std::out_of_range& e) {
59167       {
59168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59169       };
59170     } catch (std::exception& e) {
59171       {
59172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59173       };
59174     } catch (Dali::DaliException e) {
59175       {
59176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59177       };
59178     } catch (...) {
59179       {
59180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59181       };
59182     }
59183   }
59184
59185   jresult = (int)result;
59186   return jresult;
59187 }
59188
59189
59190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59191   int jresult ;
59192   int result;
59193
59194   {
59195     try {
59196       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59197     } catch (std::out_of_range& e) {
59198       {
59199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59200       };
59201     } catch (std::exception& e) {
59202       {
59203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59204       };
59205     } catch (Dali::DaliException e) {
59206       {
59207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59208       };
59209     } catch (...) {
59210       {
59211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59212       };
59213     }
59214   }
59215
59216   jresult = (int)result;
59217   return jresult;
59218 }
59219
59220
59221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59222   int jresult ;
59223   int result;
59224
59225   {
59226     try {
59227       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59228     } catch (std::out_of_range& e) {
59229       {
59230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59231       };
59232     } catch (std::exception& e) {
59233       {
59234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59235       };
59236     } catch (Dali::DaliException e) {
59237       {
59238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59239       };
59240     } catch (...) {
59241       {
59242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59243       };
59244     }
59245   }
59246
59247   jresult = (int)result;
59248   return jresult;
59249 }
59250
59251
59252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59253   int jresult ;
59254   int result;
59255
59256   {
59257     try {
59258       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59259     } catch (std::out_of_range& e) {
59260       {
59261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59262       };
59263     } catch (std::exception& e) {
59264       {
59265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59266       };
59267     } catch (Dali::DaliException e) {
59268       {
59269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59270       };
59271     } catch (...) {
59272       {
59273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59274       };
59275     }
59276   }
59277
59278   jresult = (int)result;
59279   return jresult;
59280 }
59281
59282
59283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59284   int jresult ;
59285   int result;
59286
59287   {
59288     try {
59289       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59290     } catch (std::out_of_range& e) {
59291       {
59292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59293       };
59294     } catch (std::exception& e) {
59295       {
59296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59297       };
59298     } catch (Dali::DaliException e) {
59299       {
59300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59301       };
59302     } catch (...) {
59303       {
59304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59305       };
59306     }
59307   }
59308
59309   jresult = (int)result;
59310   return jresult;
59311 }
59312
59313
59314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59315   int jresult ;
59316   int result;
59317
59318   {
59319     try {
59320       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59321     } catch (std::out_of_range& e) {
59322       {
59323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59324       };
59325     } catch (std::exception& e) {
59326       {
59327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59328       };
59329     } catch (Dali::DaliException e) {
59330       {
59331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59332       };
59333     } catch (...) {
59334       {
59335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59336       };
59337     }
59338   }
59339
59340   jresult = (int)result;
59341   return jresult;
59342 }
59343
59344
59345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59346   int jresult ;
59347   int result;
59348
59349   {
59350     try {
59351       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59352     } catch (std::out_of_range& e) {
59353       {
59354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59355       };
59356     } catch (std::exception& e) {
59357       {
59358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59359       };
59360     } catch (Dali::DaliException e) {
59361       {
59362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59363       };
59364     } catch (...) {
59365       {
59366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59367       };
59368     }
59369   }
59370
59371   jresult = (int)result;
59372   return jresult;
59373 }
59374
59375
59376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59377   int jresult ;
59378   int result;
59379
59380   {
59381     try {
59382       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59383     } catch (std::out_of_range& e) {
59384       {
59385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59386       };
59387     } catch (std::exception& e) {
59388       {
59389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59390       };
59391     } catch (Dali::DaliException e) {
59392       {
59393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59394       };
59395     } catch (...) {
59396       {
59397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59398       };
59399     }
59400   }
59401
59402   jresult = (int)result;
59403   return jresult;
59404 }
59405
59406
59407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59408   int jresult ;
59409   int result;
59410
59411   {
59412     try {
59413       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59414     } catch (std::out_of_range& e) {
59415       {
59416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59417       };
59418     } catch (std::exception& e) {
59419       {
59420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59421       };
59422     } catch (Dali::DaliException e) {
59423       {
59424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59425       };
59426     } catch (...) {
59427       {
59428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59429       };
59430     }
59431   }
59432
59433   jresult = (int)result;
59434   return jresult;
59435 }
59436
59437
59438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59439   int jresult ;
59440   int result;
59441
59442   {
59443     try {
59444       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59445     } catch (std::out_of_range& e) {
59446       {
59447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59448       };
59449     } catch (std::exception& e) {
59450       {
59451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59452       };
59453     } catch (Dali::DaliException e) {
59454       {
59455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59456       };
59457     } catch (...) {
59458       {
59459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59460       };
59461     }
59462   }
59463
59464   jresult = (int)result;
59465   return jresult;
59466 }
59467
59468
59469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59470   int jresult ;
59471   int result;
59472
59473   {
59474     try {
59475       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59476     } catch (std::out_of_range& e) {
59477       {
59478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59479       };
59480     } catch (std::exception& e) {
59481       {
59482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59483       };
59484     } catch (Dali::DaliException e) {
59485       {
59486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59487       };
59488     } catch (...) {
59489       {
59490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59491       };
59492     }
59493   }
59494
59495   jresult = (int)result;
59496   return jresult;
59497 }
59498
59499
59500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59501   int jresult ;
59502   int result;
59503
59504   {
59505     try {
59506       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59507     } catch (std::out_of_range& e) {
59508       {
59509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59510       };
59511     } catch (std::exception& e) {
59512       {
59513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59514       };
59515     } catch (Dali::DaliException e) {
59516       {
59517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59518       };
59519     } catch (...) {
59520       {
59521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59522       };
59523     }
59524   }
59525
59526   jresult = (int)result;
59527   return jresult;
59528 }
59529
59530
59531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59532   int jresult ;
59533   int result;
59534
59535   {
59536     try {
59537       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59538     } catch (std::out_of_range& e) {
59539       {
59540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59541       };
59542     } catch (std::exception& e) {
59543       {
59544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59545       };
59546     } catch (Dali::DaliException e) {
59547       {
59548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59549       };
59550     } catch (...) {
59551       {
59552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59553       };
59554     }
59555   }
59556
59557   jresult = (int)result;
59558   return jresult;
59559 }
59560
59561
59562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59563   int jresult ;
59564   int result;
59565
59566   {
59567     try {
59568       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59569     } catch (std::out_of_range& e) {
59570       {
59571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59572       };
59573     } catch (std::exception& e) {
59574       {
59575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59576       };
59577     } catch (Dali::DaliException e) {
59578       {
59579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59580       };
59581     } catch (...) {
59582       {
59583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59584       };
59585     }
59586   }
59587
59588   jresult = (int)result;
59589   return jresult;
59590 }
59591
59592
59593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59594   int jresult ;
59595   int result;
59596
59597   {
59598     try {
59599       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59600     } catch (std::out_of_range& e) {
59601       {
59602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59603       };
59604     } catch (std::exception& e) {
59605       {
59606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59607       };
59608     } catch (Dali::DaliException e) {
59609       {
59610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59611       };
59612     } catch (...) {
59613       {
59614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59615       };
59616     }
59617   }
59618
59619   jresult = (int)result;
59620   return jresult;
59621 }
59622
59623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59624   int jresult ;
59625   int result;
59626
59627   {
59628     try {
59629       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59630     } catch (std::out_of_range& e) {
59631       {
59632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59633       };
59634     } catch (std::exception& e) {
59635       {
59636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59637       };
59638     } catch (Dali::DaliException e) {
59639       {
59640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59641       };
59642     } catch (...) {
59643       {
59644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59645       };
59646     }
59647   }
59648
59649   jresult = (int)result;
59650   return jresult;
59651 }
59652
59653
59654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59655   int jresult ;
59656   int result;
59657   {
59658     try
59659     {
59660       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59661     } catch (std::out_of_range& e) {
59662       {
59663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59664       };
59665     } catch (std::exception& e) {
59666       {
59667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59668       };
59669     } catch (Dali::DaliException e) {
59670       {
59671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59672       };
59673     } catch (...) {
59674       {
59675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59676       };
59677     }
59678   }
59679
59680   jresult = (int)result;
59681   return jresult;
59682 }
59683
59684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59685   int jresult ;
59686   int result;
59687   {
59688     try
59689     {
59690       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59691     } catch (std::out_of_range& e) {
59692       {
59693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59694       };
59695     } catch (std::exception& e) {
59696       {
59697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59698       };
59699     } catch (Dali::DaliException e) {
59700       {
59701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59702       };
59703     } catch (...) {
59704       {
59705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59706       };
59707     }
59708   }
59709
59710   jresult = (int)result;
59711   return jresult;
59712 }
59713
59714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59715   int jresult ;
59716   int result;
59717   {
59718     try
59719     {
59720       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59721     } catch (std::out_of_range& e) {
59722       {
59723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59724       };
59725     } catch (std::exception& e) {
59726       {
59727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59728       };
59729     } catch (Dali::DaliException e) {
59730       {
59731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59732       };
59733     } catch (...) {
59734       {
59735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59736       };
59737     }
59738   }
59739
59740   jresult = (int)result;
59741   return jresult;
59742 }
59743
59744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59745   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59746 }
59747
59748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59749   int jresult ;
59750   int result;
59751   {
59752     try
59753     {
59754       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59755     } catch (std::out_of_range& e) {
59756       {
59757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59758       };
59759     } catch (std::exception& e) {
59760       {
59761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59762       };
59763     } catch (Dali::DaliException e) {
59764       {
59765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59766       };
59767     } catch (...) {
59768       {
59769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59770       };
59771     }
59772   }
59773
59774   jresult = (int)result;
59775   return jresult;
59776 }
59777
59778 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59779   int jresult ;
59780   int result;
59781   {
59782     try
59783     {
59784       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59785     } catch (std::out_of_range& e) {
59786       {
59787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59788       };
59789     } catch (std::exception& e) {
59790       {
59791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59792       };
59793     } catch (Dali::DaliException e) {
59794       {
59795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59796       };
59797     } catch (...) {
59798       {
59799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59800       };
59801     }
59802   }
59803
59804   jresult = (int)result;
59805   return jresult;
59806 }
59807
59808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59809   int jresult ;
59810   int result;
59811
59812   {
59813     try {
59814       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59815     } catch (std::out_of_range& e) {
59816       {
59817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59818       };
59819     } catch (std::exception& e) {
59820       {
59821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59822       };
59823     } catch (Dali::DaliException e) {
59824       {
59825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59826       };
59827     } catch (...) {
59828       {
59829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59830       };
59831     }
59832   }
59833
59834   jresult = (int)result;
59835   return jresult;
59836 }
59837
59838
59839 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59840   int jresult ;
59841   int result;
59842
59843   {
59844     try {
59845       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59846     } catch (std::out_of_range& e) {
59847       {
59848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59849       };
59850     } catch (std::exception& e) {
59851       {
59852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59853       };
59854     } catch (Dali::DaliException e) {
59855       {
59856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59857       };
59858     } catch (...) {
59859       {
59860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59861       };
59862     }
59863   }
59864
59865   jresult = (int)result;
59866   return jresult;
59867 }
59868
59869 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59870   int jresult ;
59871   int result;
59872   {
59873     try
59874     {
59875       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59876     } catch (std::out_of_range& e) {
59877       {
59878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59879       };
59880     } catch (std::exception& e) {
59881       {
59882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59883       };
59884     } catch (...) {
59885       {
59886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59887       };
59888     }
59889   }
59890   jresult = (int)result;
59891   return jresult;
59892 }
59893
59894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59895   int jresult ;
59896   int result;
59897   {
59898     try
59899     {
59900       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59901     } catch (std::out_of_range& e) {
59902       {
59903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59904       };
59905     } catch (std::exception& e) {
59906       {
59907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59908       };
59909     } catch (...) {
59910       {
59911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59912       };
59913     }
59914   }
59915   jresult = (int)result;
59916   return jresult;
59917 }
59918
59919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59920   int jresult ;
59921   int result;
59922   {
59923     try
59924     {
59925       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59926     } catch (std::out_of_range& e) {
59927       {
59928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59929       };
59930     } catch (std::exception& e) {
59931       {
59932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59933       };
59934     } catch (...) {
59935       {
59936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59937       };
59938     }
59939   }
59940   jresult = (int)result;
59941   return jresult;
59942 }
59943
59944
59945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
59946   int jresult ;
59947   int result;
59948   {
59949     try
59950     {
59951       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
59952     } catch (std::out_of_range& e) {
59953       {
59954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59955       };
59956     } catch (std::exception& e) {
59957       {
59958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59959       };
59960     } catch (...) {
59961       {
59962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59963       };
59964     }
59965   }
59966   jresult = (int)result;
59967   return jresult;
59968 }
59969
59970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
59971   int jresult ;
59972   int result;
59973   {
59974     try
59975     {
59976       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
59977     } catch (std::out_of_range& e) {
59978       {
59979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59980       };
59981     } catch (std::exception& e) {
59982       {
59983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59984       };
59985     } catch (...) {
59986       {
59987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59988       };
59989     }
59990   }
59991   jresult = (int)result;
59992   return jresult;
59993 }
59994
59995
59996
59997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
59998   int jresult ;
59999   int result;
60000
60001   {
60002     try {
60003       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
60004     } catch (std::out_of_range& e) {
60005       {
60006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60007       };
60008     } catch (std::exception& e) {
60009       {
60010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60011       };
60012     } catch (Dali::DaliException e) {
60013       {
60014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60015       };
60016     } catch (...) {
60017       {
60018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60019       };
60020     }
60021   }
60022
60023   jresult = (int)result;
60024   return jresult;
60025 }
60026
60027
60028 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
60029   int jresult ;
60030   int result;
60031
60032   {
60033     try {
60034       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
60035     } catch (std::out_of_range& e) {
60036       {
60037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60038       };
60039     } catch (std::exception& e) {
60040       {
60041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60042       };
60043     } catch (Dali::DaliException e) {
60044       {
60045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60046       };
60047     } catch (...) {
60048       {
60049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60050       };
60051     }
60052   }
60053
60054   jresult = (int)result;
60055   return jresult;
60056 }
60057
60058
60059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60060   int jresult ;
60061   int result;
60062
60063   {
60064     try {
60065       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60066     } catch (std::out_of_range& e) {
60067       {
60068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60069       };
60070     } catch (std::exception& e) {
60071       {
60072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60073       };
60074     } catch (Dali::DaliException e) {
60075       {
60076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60077       };
60078     } catch (...) {
60079       {
60080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60081       };
60082     }
60083   }
60084
60085   jresult = (int)result;
60086   return jresult;
60087 }
60088
60089
60090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60091   int jresult ;
60092   int result;
60093
60094   {
60095     try {
60096       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60097     } catch (std::out_of_range& e) {
60098       {
60099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60100       };
60101     } catch (std::exception& e) {
60102       {
60103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60104       };
60105     } catch (Dali::DaliException e) {
60106       {
60107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60108       };
60109     } catch (...) {
60110       {
60111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60112       };
60113     }
60114   }
60115
60116   jresult = (int)result;
60117   return jresult;
60118 }
60119
60120
60121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60122   int jresult ;
60123   int result;
60124
60125   {
60126     try {
60127       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60128     } catch (std::out_of_range& e) {
60129       {
60130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60131       };
60132     } catch (std::exception& e) {
60133       {
60134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60135       };
60136     } catch (Dali::DaliException e) {
60137       {
60138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60139       };
60140     } catch (...) {
60141       {
60142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60143       };
60144     }
60145   }
60146
60147   jresult = (int)result;
60148   return jresult;
60149 }
60150
60151
60152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60153   int jresult ;
60154   int result;
60155
60156   {
60157     try {
60158       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60159     } catch (std::out_of_range& e) {
60160       {
60161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60162       };
60163     } catch (std::exception& e) {
60164       {
60165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60166       };
60167     } catch (Dali::DaliException e) {
60168       {
60169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60170       };
60171     } catch (...) {
60172       {
60173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60174       };
60175     }
60176   }
60177
60178   jresult = (int)result;
60179   return jresult;
60180 }
60181
60182
60183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60184   int jresult ;
60185   int result;
60186
60187   {
60188     try {
60189       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60190     } catch (std::out_of_range& e) {
60191       {
60192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60193       };
60194     } catch (std::exception& e) {
60195       {
60196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60197       };
60198     } catch (Dali::DaliException e) {
60199       {
60200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60201       };
60202     } catch (...) {
60203       {
60204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60205       };
60206     }
60207   }
60208
60209   jresult = (int)result;
60210   return jresult;
60211 }
60212
60213 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60214   int jresult ;
60215   int result;
60216
60217   {
60218     try {
60219       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60220     } catch (std::out_of_range& e) {
60221       {
60222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60223       };
60224     } catch (std::exception& e) {
60225       {
60226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60227       };
60228     } catch (...) {
60229       {
60230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60231       };
60232     }
60233   }
60234   jresult = (int)result;
60235   return jresult;
60236 }
60237
60238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60239   int jresult ;
60240   int result;
60241
60242   {
60243     try {
60244       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60245     } catch (std::out_of_range& e) {
60246       {
60247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60248       };
60249     } catch (std::exception& e) {
60250       {
60251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60252       };
60253     } catch (Dali::DaliException e) {
60254       {
60255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60256       };
60257     } catch (...) {
60258       {
60259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60260       };
60261     }
60262   }
60263
60264   jresult = (int)result;
60265   return jresult;
60266 }
60267
60268
60269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60270   int jresult ;
60271   int result;
60272
60273   {
60274     try {
60275       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60276     } catch (std::out_of_range& e) {
60277       {
60278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60279       };
60280     } catch (std::exception& e) {
60281       {
60282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60283       };
60284     } catch (Dali::DaliException e) {
60285       {
60286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60287       };
60288     } catch (...) {
60289       {
60290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60291       };
60292     }
60293   }
60294
60295   jresult = (int)result;
60296   return jresult;
60297 }
60298
60299
60300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60301   int jresult ;
60302   int result;
60303
60304   {
60305     try {
60306       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60307     } catch (std::out_of_range& e) {
60308       {
60309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60310       };
60311     } catch (std::exception& e) {
60312       {
60313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60314       };
60315     } catch (Dali::DaliException e) {
60316       {
60317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60318       };
60319     } catch (...) {
60320       {
60321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60322       };
60323     }
60324   }
60325
60326   jresult = (int)result;
60327   return jresult;
60328 }
60329
60330
60331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60332   int jresult ;
60333   int result;
60334
60335   {
60336     try {
60337       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60338     } catch (std::out_of_range& e) {
60339       {
60340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60341       };
60342     } catch (std::exception& e) {
60343       {
60344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60345       };
60346     } catch (Dali::DaliException e) {
60347       {
60348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60349       };
60350     } catch (...) {
60351       {
60352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60353       };
60354     }
60355   }
60356
60357   jresult = (int)result;
60358   return jresult;
60359 }
60360
60361
60362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60363   int jresult ;
60364   int result;
60365
60366   {
60367     try {
60368       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60369     } catch (std::out_of_range& e) {
60370       {
60371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60372       };
60373     } catch (std::exception& e) {
60374       {
60375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60376       };
60377     } catch (Dali::DaliException e) {
60378       {
60379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60380       };
60381     } catch (...) {
60382       {
60383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60384       };
60385     }
60386   }
60387
60388   jresult = (int)result;
60389   return jresult;
60390 }
60391
60392
60393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60394   int jresult ;
60395   int result;
60396
60397   {
60398     try {
60399       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60400     } catch (std::out_of_range& e) {
60401       {
60402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60403       };
60404     } catch (std::exception& e) {
60405       {
60406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60407       };
60408     } catch (Dali::DaliException e) {
60409       {
60410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60411       };
60412     } catch (...) {
60413       {
60414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60415       };
60416     }
60417   }
60418
60419   jresult = (int)result;
60420   return jresult;
60421 }
60422
60423
60424 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60425   int jresult ;
60426   int result;
60427
60428   {
60429     try {
60430       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60431     } catch (std::out_of_range& e) {
60432       {
60433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60434       };
60435     } catch (std::exception& e) {
60436       {
60437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60438       };
60439     } catch (Dali::DaliException e) {
60440       {
60441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60442       };
60443     } catch (...) {
60444       {
60445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60446       };
60447     }
60448   }
60449
60450   jresult = (int)result;
60451   return jresult;
60452 }
60453
60454
60455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60456   int jresult ;
60457   int result;
60458
60459   {
60460     try {
60461       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60462     } catch (std::out_of_range& e) {
60463       {
60464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60465       };
60466     } catch (std::exception& e) {
60467       {
60468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60469       };
60470     } catch (Dali::DaliException e) {
60471       {
60472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60473       };
60474     } catch (...) {
60475       {
60476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60477       };
60478     }
60479   }
60480
60481   jresult = (int)result;
60482   return jresult;
60483 }
60484
60485
60486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60487   int jresult ;
60488   int result;
60489
60490   {
60491     try {
60492       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60493     } catch (std::out_of_range& e) {
60494       {
60495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60496       };
60497     } catch (std::exception& e) {
60498       {
60499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60500       };
60501     } catch (Dali::DaliException e) {
60502       {
60503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60504       };
60505     } catch (...) {
60506       {
60507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60508       };
60509     }
60510   }
60511
60512   jresult = (int)result;
60513   return jresult;
60514 }
60515
60516
60517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60518   int jresult ;
60519   int result;
60520
60521   {
60522     try {
60523       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60524     } catch (std::out_of_range& e) {
60525       {
60526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60527       };
60528     } catch (std::exception& e) {
60529       {
60530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60531       };
60532     } catch (Dali::DaliException e) {
60533       {
60534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60535       };
60536     } catch (...) {
60537       {
60538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60539       };
60540     }
60541   }
60542
60543   jresult = (int)result;
60544   return jresult;
60545 }
60546
60547
60548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60549   int jresult ;
60550   int result;
60551
60552   {
60553     try {
60554       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60555     } catch (std::out_of_range& e) {
60556       {
60557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60558       };
60559     } catch (std::exception& e) {
60560       {
60561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60562       };
60563     } catch (Dali::DaliException e) {
60564       {
60565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60566       };
60567     } catch (...) {
60568       {
60569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60570       };
60571     }
60572   }
60573
60574   jresult = (int)result;
60575   return jresult;
60576 }
60577
60578
60579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60580   int jresult ;
60581   int result;
60582
60583   {
60584     try {
60585       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60586     } catch (std::out_of_range& e) {
60587       {
60588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60589       };
60590     } catch (std::exception& e) {
60591       {
60592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60593       };
60594     } catch (Dali::DaliException e) {
60595       {
60596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60597       };
60598     } catch (...) {
60599       {
60600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60601       };
60602     }
60603   }
60604
60605   jresult = (int)result;
60606   return jresult;
60607 }
60608
60609
60610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60611   int jresult ;
60612   int result;
60613
60614   {
60615     try {
60616       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60617     } catch (std::out_of_range& e) {
60618       {
60619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60620       };
60621     } catch (std::exception& e) {
60622       {
60623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60624       };
60625     } catch (Dali::DaliException e) {
60626       {
60627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60628       };
60629     } catch (...) {
60630       {
60631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60632       };
60633     }
60634   }
60635
60636   jresult = (int)result;
60637   return jresult;
60638 }
60639
60640
60641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60642   int jresult ;
60643   int result;
60644
60645   {
60646     try {
60647       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60648     } catch (std::out_of_range& e) {
60649       {
60650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60651       };
60652     } catch (std::exception& e) {
60653       {
60654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60655       };
60656     } catch (Dali::DaliException e) {
60657       {
60658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60659       };
60660     } catch (...) {
60661       {
60662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60663       };
60664     }
60665   }
60666
60667   jresult = (int)result;
60668   return jresult;
60669 }
60670
60671
60672 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60673   int jresult ;
60674   int result;
60675
60676   {
60677     try {
60678       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60679     } catch (std::out_of_range& e) {
60680       {
60681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60682       };
60683     } catch (std::exception& e) {
60684       {
60685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60686       };
60687     } catch (Dali::DaliException e) {
60688       {
60689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60690       };
60691     } catch (...) {
60692       {
60693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60694       };
60695     }
60696   }
60697
60698   jresult = (int)result;
60699   return jresult;
60700 }
60701
60702
60703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60704   int jresult ;
60705   int result;
60706
60707   {
60708     try {
60709       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60710     } catch (std::out_of_range& e) {
60711       {
60712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60713       };
60714     } catch (std::exception& e) {
60715       {
60716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60717       };
60718     } catch (Dali::DaliException e) {
60719       {
60720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60721       };
60722     } catch (...) {
60723       {
60724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60725       };
60726     }
60727   }
60728
60729   jresult = (int)result;
60730   return jresult;
60731 }
60732
60733
60734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60735   int jresult ;
60736   int result;
60737
60738   {
60739     try {
60740       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60741     } catch (std::out_of_range& e) {
60742       {
60743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60744       };
60745     } catch (std::exception& e) {
60746       {
60747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60748       };
60749     } catch (Dali::DaliException e) {
60750       {
60751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60752       };
60753     } catch (...) {
60754       {
60755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60756       };
60757     }
60758   }
60759
60760   jresult = (int)result;
60761   return jresult;
60762 }
60763
60764
60765 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60766   int jresult ;
60767   int result;
60768
60769   {
60770     try {
60771       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60772     } catch (std::out_of_range& e) {
60773       {
60774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60775       };
60776     } catch (std::exception& e) {
60777       {
60778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60779       };
60780     } catch (Dali::DaliException e) {
60781       {
60782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60783       };
60784     } catch (...) {
60785       {
60786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60787       };
60788     }
60789   }
60790
60791   jresult = (int)result;
60792   return jresult;
60793 }
60794
60795
60796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60797   int jresult ;
60798   int result;
60799
60800   {
60801     try {
60802       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60803     } catch (std::out_of_range& e) {
60804       {
60805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60806       };
60807     } catch (std::exception& e) {
60808       {
60809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60810       };
60811     } catch (Dali::DaliException e) {
60812       {
60813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60814       };
60815     } catch (...) {
60816       {
60817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60818       };
60819     }
60820   }
60821
60822   jresult = (int)result;
60823   return jresult;
60824 }
60825
60826
60827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60828   int jresult ;
60829   int result;
60830
60831   {
60832     try {
60833       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60834     } catch (std::out_of_range& e) {
60835       {
60836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60837       };
60838     } catch (std::exception& e) {
60839       {
60840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60841       };
60842     } catch (Dali::DaliException e) {
60843       {
60844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60845       };
60846     } catch (...) {
60847       {
60848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60849       };
60850     }
60851   }
60852
60853   jresult = (int)result;
60854   return jresult;
60855 }
60856
60857
60858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60859   int jresult ;
60860   int result;
60861
60862   {
60863     try {
60864       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60865     } catch (std::out_of_range& e) {
60866       {
60867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60868       };
60869     } catch (std::exception& e) {
60870       {
60871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60872       };
60873     } catch (Dali::DaliException e) {
60874       {
60875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60876       };
60877     } catch (...) {
60878       {
60879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60880       };
60881     }
60882   }
60883
60884   jresult = (int)result;
60885   return jresult;
60886 }
60887
60888
60889 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60890   int jresult ;
60891   int result;
60892
60893   {
60894     try {
60895       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60896     } catch (std::out_of_range& e) {
60897       {
60898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60899       };
60900     } catch (std::exception& e) {
60901       {
60902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60903       };
60904     } catch (Dali::DaliException e) {
60905       {
60906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60907       };
60908     } catch (...) {
60909       {
60910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60911       };
60912     }
60913   }
60914
60915   jresult = (int)result;
60916   return jresult;
60917 }
60918
60919
60920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60921   int jresult ;
60922   int result;
60923
60924   {
60925     try {
60926       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60927     } catch (std::out_of_range& e) {
60928       {
60929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60930       };
60931     } catch (std::exception& e) {
60932       {
60933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60934       };
60935     } catch (Dali::DaliException e) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60938       };
60939     } catch (...) {
60940       {
60941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60942       };
60943     }
60944   }
60945
60946   jresult = (int)result;
60947   return jresult;
60948 }
60949
60950
60951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
60952   int jresult ;
60953   int result;
60954
60955   {
60956     try {
60957       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
60958     } catch (std::out_of_range& e) {
60959       {
60960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60961       };
60962     } catch (std::exception& e) {
60963       {
60964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60965       };
60966     } catch (Dali::DaliException e) {
60967       {
60968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60969       };
60970     } catch (...) {
60971       {
60972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60973       };
60974     }
60975   }
60976
60977   jresult = (int)result;
60978   return jresult;
60979 }
60980
60981
60982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
60983   int jresult ;
60984   int result;
60985
60986   {
60987     try {
60988       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
60989     } catch (std::out_of_range& e) {
60990       {
60991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60992       };
60993     } catch (std::exception& e) {
60994       {
60995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60996       };
60997     } catch (Dali::DaliException e) {
60998       {
60999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61000       };
61001     } catch (...) {
61002       {
61003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61004       };
61005     }
61006   }
61007
61008   jresult = (int)result;
61009   return jresult;
61010 }
61011
61012
61013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
61014   int jresult ;
61015   int result;
61016
61017   {
61018     try {
61019       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
61020     } catch (std::out_of_range& e) {
61021       {
61022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61023       };
61024     } catch (std::exception& e) {
61025       {
61026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61027       };
61028     } catch (Dali::DaliException e) {
61029       {
61030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61031       };
61032     } catch (...) {
61033       {
61034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61035       };
61036     }
61037   }
61038
61039   jresult = (int)result;
61040   return jresult;
61041 }
61042
61043
61044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61045   int jresult ;
61046   int result;
61047
61048   {
61049     try {
61050       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61051     } catch (std::out_of_range& e) {
61052       {
61053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61054       };
61055     } catch (std::exception& e) {
61056       {
61057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61058       };
61059     } catch (Dali::DaliException e) {
61060       {
61061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61062       };
61063     } catch (...) {
61064       {
61065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61066       };
61067     }
61068   }
61069
61070   jresult = (int)result;
61071   return jresult;
61072 }
61073
61074
61075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61076   int jresult ;
61077   int result;
61078
61079   {
61080     try {
61081       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61082     } catch (std::out_of_range& e) {
61083       {
61084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61085       };
61086     } catch (std::exception& e) {
61087       {
61088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61089       };
61090     } catch (Dali::DaliException e) {
61091       {
61092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61093       };
61094     } catch (...) {
61095       {
61096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61097       };
61098     }
61099   }
61100
61101   jresult = (int)result;
61102   return jresult;
61103 }
61104
61105
61106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61107   void * jresult ;
61108   Dali::Toolkit::Builder *result = 0 ;
61109
61110   {
61111     try {
61112       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61113     } catch (std::out_of_range& e) {
61114       {
61115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61116       };
61117     } catch (std::exception& e) {
61118       {
61119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61120       };
61121     } catch (Dali::DaliException e) {
61122       {
61123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61124       };
61125     } catch (...) {
61126       {
61127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61128       };
61129     }
61130   }
61131
61132   jresult = (void *)result;
61133   return jresult;
61134 }
61135
61136
61137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61138   void * jresult ;
61139   Dali::Toolkit::Builder result;
61140
61141   {
61142     try {
61143       result = Dali::Toolkit::Builder::New();
61144     } catch (std::out_of_range& e) {
61145       {
61146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61147       };
61148     } catch (std::exception& e) {
61149       {
61150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61151       };
61152     } catch (Dali::DaliException e) {
61153       {
61154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61155       };
61156     } catch (...) {
61157       {
61158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61159       };
61160     }
61161   }
61162
61163   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61164   return jresult;
61165 }
61166
61167
61168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61169   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61170
61171   arg1 = (Dali::Toolkit::Builder *)jarg1;
61172   {
61173     try {
61174       delete arg1;
61175     } catch (std::out_of_range& e) {
61176       {
61177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61178       };
61179     } catch (std::exception& e) {
61180       {
61181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61182       };
61183     } catch (Dali::DaliException e) {
61184       {
61185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61186       };
61187     } catch (...) {
61188       {
61189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61190       };
61191     }
61192   }
61193
61194 }
61195
61196
61197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61198   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61199   std::string *arg2 = 0 ;
61200   Dali::Toolkit::Builder::UIFormat arg3 ;
61201
61202   arg1 = (Dali::Toolkit::Builder *)jarg1;
61203   if (!jarg2) {
61204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61205     return ;
61206   }
61207   std::string arg2_str(jarg2);
61208   arg2 = &arg2_str;
61209   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61210   {
61211     try {
61212       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61213     } catch (std::out_of_range& e) {
61214       {
61215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61216       };
61217     } catch (std::exception& e) {
61218       {
61219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61220       };
61221     } catch (Dali::DaliException e) {
61222       {
61223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61224       };
61225     } catch (...) {
61226       {
61227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61228       };
61229     }
61230   }
61231
61232
61233   //argout typemap for const std::string&
61234
61235 }
61236
61237
61238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61239   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61240   std::string *arg2 = 0 ;
61241
61242   arg1 = (Dali::Toolkit::Builder *)jarg1;
61243   if (!jarg2) {
61244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61245     return ;
61246   }
61247   std::string arg2_str(jarg2);
61248   arg2 = &arg2_str;
61249   {
61250     try {
61251       (arg1)->LoadFromString((std::string const &)*arg2);
61252     } catch (std::out_of_range& e) {
61253       {
61254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61255       };
61256     } catch (std::exception& e) {
61257       {
61258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61259       };
61260     } catch (Dali::DaliException e) {
61261       {
61262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61263       };
61264     } catch (...) {
61265       {
61266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61267       };
61268     }
61269   }
61270
61271
61272   //argout typemap for const std::string&
61273
61274 }
61275
61276
61277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
61278   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61279   Dali::Property::Map *arg2 = 0 ;
61280
61281   arg1 = (Dali::Toolkit::Builder *)jarg1;
61282   arg2 = (Dali::Property::Map *)jarg2;
61283   if (!arg2) {
61284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61285     return ;
61286   }
61287   {
61288     try {
61289       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61290     } catch (std::out_of_range& e) {
61291       {
61292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61293       };
61294     } catch (std::exception& e) {
61295       {
61296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61297       };
61298     } catch (Dali::DaliException e) {
61299       {
61300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61301       };
61302     } catch (...) {
61303       {
61304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61305       };
61306     }
61307   }
61308
61309 }
61310
61311
61312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61313   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61314   std::string *arg2 = 0 ;
61315   Dali::Property::Value *arg3 = 0 ;
61316
61317   arg1 = (Dali::Toolkit::Builder *)jarg1;
61318   if (!jarg2) {
61319     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61320     return ;
61321   }
61322   std::string arg2_str(jarg2);
61323   arg2 = &arg2_str;
61324   arg3 = (Dali::Property::Value *)jarg3;
61325   if (!arg3) {
61326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61327     return ;
61328   }
61329   {
61330     try {
61331       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61332     } catch (std::out_of_range& e) {
61333       {
61334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61335       };
61336     } catch (std::exception& e) {
61337       {
61338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61339       };
61340     } catch (Dali::DaliException e) {
61341       {
61342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61343       };
61344     } catch (...) {
61345       {
61346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61347       };
61348     }
61349   }
61350
61351
61352   //argout typemap for const std::string&
61353
61354 }
61355
61356
61357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61358   void * jresult ;
61359   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61360   Dali::Property::Map *result = 0 ;
61361
61362   arg1 = (Dali::Toolkit::Builder *)jarg1;
61363   {
61364     try {
61365       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61366     } catch (std::out_of_range& e) {
61367       {
61368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61369       };
61370     } catch (std::exception& e) {
61371       {
61372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61373       };
61374     } catch (Dali::DaliException e) {
61375       {
61376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61377       };
61378     } catch (...) {
61379       {
61380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61381       };
61382     }
61383   }
61384
61385   jresult = (void *)result;
61386   return jresult;
61387 }
61388
61389
61390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61391   void * jresult ;
61392   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61393   std::string *arg2 = 0 ;
61394   Dali::Property::Value *result = 0 ;
61395
61396   arg1 = (Dali::Toolkit::Builder *)jarg1;
61397   if (!jarg2) {
61398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61399     return 0;
61400   }
61401   std::string arg2_str(jarg2);
61402   arg2 = &arg2_str;
61403   {
61404     try {
61405       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61406     } catch (std::out_of_range& e) {
61407       {
61408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61409       };
61410     } catch (std::exception& e) {
61411       {
61412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61413       };
61414     } catch (Dali::DaliException e) {
61415       {
61416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61417       };
61418     } catch (...) {
61419       {
61420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61421       };
61422     }
61423   }
61424
61425   jresult = (void *)result;
61426
61427   //argout typemap for const std::string&
61428
61429   return jresult;
61430 }
61431
61432
61433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61434   void * jresult ;
61435   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61436   std::string *arg2 = 0 ;
61437   Dali::Animation result;
61438
61439   arg1 = (Dali::Toolkit::Builder *)jarg1;
61440   if (!jarg2) {
61441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61442     return 0;
61443   }
61444   std::string arg2_str(jarg2);
61445   arg2 = &arg2_str;
61446   {
61447     try {
61448       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61449     } catch (std::out_of_range& e) {
61450       {
61451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61452       };
61453     } catch (std::exception& e) {
61454       {
61455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61456       };
61457     } catch (Dali::DaliException e) {
61458       {
61459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61460       };
61461     } catch (...) {
61462       {
61463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61464       };
61465     }
61466   }
61467
61468   jresult = new Dali::Animation((const Dali::Animation &)result);
61469
61470   //argout typemap for const std::string&
61471
61472   return jresult;
61473 }
61474
61475
61476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61477   void * jresult ;
61478   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61479   std::string *arg2 = 0 ;
61480   Dali::Property::Map *arg3 = 0 ;
61481   Dali::Animation result;
61482
61483   arg1 = (Dali::Toolkit::Builder *)jarg1;
61484   if (!jarg2) {
61485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61486     return 0;
61487   }
61488   std::string arg2_str(jarg2);
61489   arg2 = &arg2_str;
61490   arg3 = (Dali::Property::Map *)jarg3;
61491   if (!arg3) {
61492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61493     return 0;
61494   }
61495   {
61496     try {
61497       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61498     } catch (std::out_of_range& e) {
61499       {
61500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61501       };
61502     } catch (std::exception& e) {
61503       {
61504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61505       };
61506     } catch (Dali::DaliException e) {
61507       {
61508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61509       };
61510     } catch (...) {
61511       {
61512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61513       };
61514     }
61515   }
61516
61517   jresult = new Dali::Animation((const Dali::Animation &)result);
61518
61519   //argout typemap for const std::string&
61520
61521   return jresult;
61522 }
61523
61524
61525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61526   void * jresult ;
61527   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61528   std::string *arg2 = 0 ;
61529   Dali::Actor arg3 ;
61530   Dali::Actor *argp3 ;
61531   Dali::Animation result;
61532
61533   arg1 = (Dali::Toolkit::Builder *)jarg1;
61534   if (!jarg2) {
61535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61536     return 0;
61537   }
61538   std::string arg2_str(jarg2);
61539   arg2 = &arg2_str;
61540   argp3 = (Dali::Actor *)jarg3;
61541   if (!argp3) {
61542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61543     return 0;
61544   }
61545   arg3 = *argp3;
61546   {
61547     try {
61548       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61549     } catch (std::out_of_range& e) {
61550       {
61551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61552       };
61553     } catch (std::exception& e) {
61554       {
61555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61556       };
61557     } catch (Dali::DaliException e) {
61558       {
61559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61560       };
61561     } catch (...) {
61562       {
61563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61564       };
61565     }
61566   }
61567
61568   jresult = new Dali::Animation((const Dali::Animation &)result);
61569
61570   //argout typemap for const std::string&
61571
61572   return jresult;
61573 }
61574
61575
61576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61577   void * jresult ;
61578   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61579   std::string *arg2 = 0 ;
61580   Dali::Property::Map *arg3 = 0 ;
61581   Dali::Actor arg4 ;
61582   Dali::Actor *argp4 ;
61583   Dali::Animation result;
61584
61585   arg1 = (Dali::Toolkit::Builder *)jarg1;
61586   if (!jarg2) {
61587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61588     return 0;
61589   }
61590   std::string arg2_str(jarg2);
61591   arg2 = &arg2_str;
61592   arg3 = (Dali::Property::Map *)jarg3;
61593   if (!arg3) {
61594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61595     return 0;
61596   }
61597   argp4 = (Dali::Actor *)jarg4;
61598   if (!argp4) {
61599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61600     return 0;
61601   }
61602   arg4 = *argp4;
61603   {
61604     try {
61605       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61606     } catch (std::out_of_range& e) {
61607       {
61608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61609       };
61610     } catch (std::exception& e) {
61611       {
61612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61613       };
61614     } catch (Dali::DaliException e) {
61615       {
61616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61617       };
61618     } catch (...) {
61619       {
61620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61621       };
61622     }
61623   }
61624
61625   jresult = new Dali::Animation((const Dali::Animation &)result);
61626
61627   //argout typemap for const std::string&
61628
61629   return jresult;
61630 }
61631
61632
61633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61634   void * jresult ;
61635   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61636   std::string *arg2 = 0 ;
61637   Dali::BaseHandle result;
61638
61639   arg1 = (Dali::Toolkit::Builder *)jarg1;
61640   if (!jarg2) {
61641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61642     return 0;
61643   }
61644   std::string arg2_str(jarg2);
61645   arg2 = &arg2_str;
61646   {
61647     try {
61648       result = (arg1)->Create((std::string const &)*arg2);
61649     } catch (std::out_of_range& e) {
61650       {
61651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61652       };
61653     } catch (std::exception& e) {
61654       {
61655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61656       };
61657     } catch (Dali::DaliException e) {
61658       {
61659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61660       };
61661     } catch (...) {
61662       {
61663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61664       };
61665     }
61666   }
61667
61668   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61669
61670   //argout typemap for const std::string&
61671
61672   return jresult;
61673 }
61674
61675
61676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61677   void * jresult ;
61678   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61679   std::string *arg2 = 0 ;
61680   Dali::Property::Map *arg3 = 0 ;
61681   Dali::BaseHandle result;
61682
61683   arg1 = (Dali::Toolkit::Builder *)jarg1;
61684   if (!jarg2) {
61685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61686     return 0;
61687   }
61688   std::string arg2_str(jarg2);
61689   arg2 = &arg2_str;
61690   arg3 = (Dali::Property::Map *)jarg3;
61691   if (!arg3) {
61692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61693     return 0;
61694   }
61695   {
61696     try {
61697       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61698     } catch (std::out_of_range& e) {
61699       {
61700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61701       };
61702     } catch (std::exception& e) {
61703       {
61704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61705       };
61706     } catch (Dali::DaliException e) {
61707       {
61708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61709       };
61710     } catch (...) {
61711       {
61712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61713       };
61714     }
61715   }
61716
61717   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61718
61719   //argout typemap for const std::string&
61720
61721   return jresult;
61722 }
61723
61724
61725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61726   void * jresult ;
61727   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61728   std::string *arg2 = 0 ;
61729   Dali::BaseHandle result;
61730
61731   arg1 = (Dali::Toolkit::Builder *)jarg1;
61732   if (!jarg2) {
61733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61734     return 0;
61735   }
61736   std::string arg2_str(jarg2);
61737   arg2 = &arg2_str;
61738   {
61739     try {
61740       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61741     } catch (std::out_of_range& e) {
61742       {
61743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61744       };
61745     } catch (std::exception& e) {
61746       {
61747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61748       };
61749     } catch (Dali::DaliException e) {
61750       {
61751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61752       };
61753     } catch (...) {
61754       {
61755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61756       };
61757     }
61758   }
61759
61760   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61761
61762   //argout typemap for const std::string&
61763
61764   return jresult;
61765 }
61766
61767
61768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61769   unsigned int jresult ;
61770   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61771   std::string *arg2 = 0 ;
61772   Dali::Handle *arg3 = 0 ;
61773   bool result;
61774
61775   arg1 = (Dali::Toolkit::Builder *)jarg1;
61776   if (!jarg2) {
61777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61778     return 0;
61779   }
61780   std::string arg2_str(jarg2);
61781   arg2 = &arg2_str;
61782   arg3 = (Dali::Handle *)jarg3;
61783   if (!arg3) {
61784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61785     return 0;
61786   }
61787   {
61788     try {
61789       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61790     } catch (std::out_of_range& e) {
61791       {
61792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61793       };
61794     } catch (std::exception& e) {
61795       {
61796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61797       };
61798     } catch (Dali::DaliException e) {
61799       {
61800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61801       };
61802     } catch (...) {
61803       {
61804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61805       };
61806     }
61807   }
61808
61809   jresult = result;
61810
61811   //argout typemap for const std::string&
61812
61813   return jresult;
61814 }
61815
61816
61817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61818   unsigned int jresult ;
61819   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61820   Dali::Handle *arg2 = 0 ;
61821   std::string *arg3 = 0 ;
61822   bool result;
61823
61824   arg1 = (Dali::Toolkit::Builder *)jarg1;
61825   arg2 = (Dali::Handle *)jarg2;
61826   if (!arg2) {
61827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61828     return 0;
61829   }
61830   if (!jarg3) {
61831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61832     return 0;
61833   }
61834   std::string arg3_str(jarg3);
61835   arg3 = &arg3_str;
61836   {
61837     try {
61838       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61839     } catch (std::out_of_range& e) {
61840       {
61841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61842       };
61843     } catch (std::exception& e) {
61844       {
61845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61846       };
61847     } catch (Dali::DaliException e) {
61848       {
61849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61850       };
61851     } catch (...) {
61852       {
61853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61854       };
61855     }
61856   }
61857
61858   jresult = result;
61859
61860   //argout typemap for const std::string&
61861
61862   return jresult;
61863 }
61864
61865
61866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61867   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61868   Dali::Actor arg2 ;
61869   Dali::Actor *argp2 ;
61870
61871   arg1 = (Dali::Toolkit::Builder *)jarg1;
61872   argp2 = (Dali::Actor *)jarg2;
61873   if (!argp2) {
61874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61875     return ;
61876   }
61877   arg2 = *argp2;
61878   {
61879     try {
61880       (arg1)->AddActors(arg2);
61881     } catch (std::out_of_range& e) {
61882       {
61883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61884       };
61885     } catch (std::exception& e) {
61886       {
61887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61888       };
61889     } catch (Dali::DaliException e) {
61890       {
61891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61892       };
61893     } catch (...) {
61894       {
61895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61896       };
61897     }
61898   }
61899
61900 }
61901
61902
61903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61904   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61905   std::string *arg2 = 0 ;
61906   Dali::Actor arg3 ;
61907   Dali::Actor *argp3 ;
61908
61909   arg1 = (Dali::Toolkit::Builder *)jarg1;
61910   if (!jarg2) {
61911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61912     return ;
61913   }
61914   std::string arg2_str(jarg2);
61915   arg2 = &arg2_str;
61916   argp3 = (Dali::Actor *)jarg3;
61917   if (!argp3) {
61918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61919     return ;
61920   }
61921   arg3 = *argp3;
61922   {
61923     try {
61924       (arg1)->AddActors((std::string const &)*arg2,arg3);
61925     } catch (std::out_of_range& e) {
61926       {
61927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61928       };
61929     } catch (std::exception& e) {
61930       {
61931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61932       };
61933     } catch (Dali::DaliException e) {
61934       {
61935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61936       };
61937     } catch (...) {
61938       {
61939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61940       };
61941     }
61942   }
61943
61944
61945   //argout typemap for const std::string&
61946
61947 }
61948
61949
61950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
61951   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61952   std::string *arg2 = 0 ;
61953
61954   arg1 = (Dali::Toolkit::Builder *)jarg1;
61955   if (!jarg2) {
61956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61957     return ;
61958   }
61959   std::string arg2_str(jarg2);
61960   arg2 = &arg2_str;
61961   {
61962     try {
61963       (arg1)->CreateRenderTask((std::string const &)*arg2);
61964     } catch (std::out_of_range& e) {
61965       {
61966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61967       };
61968     } catch (std::exception& e) {
61969       {
61970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61971       };
61972     } catch (Dali::DaliException e) {
61973       {
61974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61975       };
61976     } catch (...) {
61977       {
61978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61979       };
61980     }
61981   }
61982
61983
61984   //argout typemap for const std::string&
61985
61986 }
61987
61988
61989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetFrameBufferImage(void * jarg1, char * jarg2) {
61990   void * jresult ;
61991   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61992   std::string *arg2 = 0 ;
61993   Dali::FrameBufferImage result;
61994
61995   arg1 = (Dali::Toolkit::Builder *)jarg1;
61996   if (!jarg2) {
61997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61998     return 0;
61999   }
62000   std::string arg2_str(jarg2);
62001   arg2 = &arg2_str;
62002   {
62003     try {
62004       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
62005     } catch (std::out_of_range& e) {
62006       {
62007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62008       };
62009     } catch (std::exception& e) {
62010       {
62011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62012       };
62013     } catch (Dali::DaliException e) {
62014       {
62015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62016       };
62017     } catch (...) {
62018       {
62019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62020       };
62021     }
62022   }
62023
62024   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
62025
62026   //argout typemap for const std::string&
62027
62028   return jresult;
62029 }
62030
62031
62032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
62033   void * jresult ;
62034   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62035   std::string *arg2 = 0 ;
62036   Dali::Path result;
62037
62038   arg1 = (Dali::Toolkit::Builder *)jarg1;
62039   if (!jarg2) {
62040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62041     return 0;
62042   }
62043   std::string arg2_str(jarg2);
62044   arg2 = &arg2_str;
62045   {
62046     try {
62047       result = (arg1)->GetPath((std::string const &)*arg2);
62048     } catch (std::out_of_range& e) {
62049       {
62050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62051       };
62052     } catch (std::exception& e) {
62053       {
62054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62055       };
62056     } catch (Dali::DaliException e) {
62057       {
62058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62059       };
62060     } catch (...) {
62061       {
62062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62063       };
62064     }
62065   }
62066
62067   jresult = new Dali::Path((const Dali::Path &)result);
62068
62069   //argout typemap for const std::string&
62070
62071   return jresult;
62072 }
62073
62074
62075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62076   void * jresult ;
62077   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62078   std::string *arg2 = 0 ;
62079   Dali::PathConstrainer result;
62080
62081   arg1 = (Dali::Toolkit::Builder *)jarg1;
62082   if (!jarg2) {
62083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62084     return 0;
62085   }
62086   std::string arg2_str(jarg2);
62087   arg2 = &arg2_str;
62088   {
62089     try {
62090       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62091     } catch (std::out_of_range& e) {
62092       {
62093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62094       };
62095     } catch (std::exception& e) {
62096       {
62097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62098       };
62099     } catch (Dali::DaliException e) {
62100       {
62101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62102       };
62103     } catch (...) {
62104       {
62105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62106       };
62107     }
62108   }
62109
62110   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62111
62112   //argout typemap for const std::string&
62113
62114   return jresult;
62115 }
62116
62117
62118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62119   void * jresult ;
62120   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62121   std::string *arg2 = 0 ;
62122   Dali::LinearConstrainer result;
62123
62124   arg1 = (Dali::Toolkit::Builder *)jarg1;
62125   if (!jarg2) {
62126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62127     return 0;
62128   }
62129   std::string arg2_str(jarg2);
62130   arg2 = &arg2_str;
62131   {
62132     try {
62133       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62134     } catch (std::out_of_range& e) {
62135       {
62136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62137       };
62138     } catch (std::exception& e) {
62139       {
62140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62141       };
62142     } catch (Dali::DaliException e) {
62143       {
62144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62145       };
62146     } catch (...) {
62147       {
62148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62149       };
62150     }
62151   }
62152
62153   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62154
62155   //argout typemap for const std::string&
62156
62157   return jresult;
62158 }
62159
62160
62161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62162   void * jresult ;
62163   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62164   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62165
62166   arg1 = (Dali::Toolkit::Builder *)jarg1;
62167   {
62168     try {
62169       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62170     } catch (std::out_of_range& e) {
62171       {
62172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62173       };
62174     } catch (std::exception& e) {
62175       {
62176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62177       };
62178     } catch (Dali::DaliException e) {
62179       {
62180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62181       };
62182     } catch (...) {
62183       {
62184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62185       };
62186     }
62187   }
62188
62189   jresult = (void *)result;
62190   return jresult;
62191 }
62192
62193
62194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62195   void * jresult ;
62196   Dali::Toolkit::TransitionData *result = 0 ;
62197
62198   {
62199     try {
62200       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62201     } catch (std::out_of_range& e) {
62202       {
62203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62204       };
62205     } catch (std::exception& e) {
62206       {
62207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62208       };
62209     } catch (Dali::DaliException e) {
62210       {
62211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62212       };
62213     } catch (...) {
62214       {
62215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62216       };
62217     }
62218   }
62219
62220   jresult = (void *)result;
62221   return jresult;
62222 }
62223
62224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62225   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62226
62227   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62228   {
62229     try {
62230       delete arg1;
62231     } catch (std::out_of_range& e) {
62232       {
62233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62234       };
62235     } catch (std::exception& e) {
62236       {
62237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62238       };
62239     } catch (Dali::DaliException e) {
62240       {
62241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62242       };
62243     } catch (...) {
62244       {
62245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62246       };
62247     }
62248   }
62249
62250 }
62251
62252
62253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62254   void * jresult ;
62255   Dali::Property::Map *arg1 = 0 ;
62256   Dali::Toolkit::TransitionData result;
62257
62258   arg1 = (Dali::Property::Map *)jarg1;
62259   if (!arg1) {
62260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62261     return 0;
62262   }
62263   {
62264     try {
62265       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62266     } catch (std::out_of_range& e) {
62267       {
62268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62269       };
62270     } catch (std::exception& e) {
62271       {
62272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62273       };
62274     } catch (Dali::DaliException e) {
62275       {
62276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62277       };
62278     } catch (...) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62281       };
62282     }
62283   }
62284
62285   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62286   return jresult;
62287 }
62288
62289
62290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62291   void * jresult ;
62292   Dali::Property::Array *arg1 = 0 ;
62293   Dali::Toolkit::TransitionData result;
62294
62295   arg1 = (Dali::Property::Array *)jarg1;
62296   if (!arg1) {
62297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62298     return 0;
62299   }
62300   {
62301     try {
62302       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62303     } catch (std::out_of_range& e) {
62304       {
62305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62306       };
62307     } catch (std::exception& e) {
62308       {
62309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62310       };
62311     } catch (Dali::DaliException e) {
62312       {
62313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62314       };
62315     } catch (...) {
62316       {
62317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62318       };
62319     }
62320   }
62321
62322   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62323   return jresult;
62324 }
62325
62326
62327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62328   void * jresult ;
62329   Dali::BaseHandle arg1 ;
62330   Dali::BaseHandle *argp1 ;
62331   Dali::Toolkit::TransitionData result;
62332
62333   argp1 = (Dali::BaseHandle *)jarg1;
62334   if (!argp1) {
62335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62336     return 0;
62337   }
62338   arg1 = *argp1;
62339   {
62340     try {
62341       result = Dali::Toolkit::TransitionData::DownCast(arg1);
62342     } catch (std::out_of_range& e) {
62343       {
62344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62345       };
62346     } catch (std::exception& e) {
62347       {
62348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62349       };
62350     } catch (Dali::DaliException e) {
62351       {
62352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62353       };
62354     } catch (...) {
62355       {
62356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62357       };
62358     }
62359   }
62360
62361   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62362   return jresult;
62363 }
62364
62365
62366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
62367   void * jresult ;
62368   Dali::Toolkit::TransitionData *arg1 = 0 ;
62369   Dali::Toolkit::TransitionData *result = 0 ;
62370
62371   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62372   if (!arg1) {
62373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62374     return 0;
62375   }
62376   {
62377     try {
62378       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62379     } catch (std::out_of_range& e) {
62380       {
62381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62382       };
62383     } catch (std::exception& e) {
62384       {
62385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62386       };
62387     } catch (Dali::DaliException e) {
62388       {
62389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62390       };
62391     } catch (...) {
62392       {
62393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62394       };
62395     }
62396   }
62397
62398   jresult = (void *)result;
62399   return jresult;
62400 }
62401
62402
62403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62404   void * jresult ;
62405   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62406   Dali::Toolkit::TransitionData *arg2 = 0 ;
62407   Dali::Toolkit::TransitionData *result = 0 ;
62408
62409   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62410   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62411   if (!arg2) {
62412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62413     return 0;
62414   }
62415   {
62416     try {
62417       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
62418     } catch (std::out_of_range& e) {
62419       {
62420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62421       };
62422     } catch (std::exception& e) {
62423       {
62424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62425       };
62426     } catch (Dali::DaliException e) {
62427       {
62428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62429       };
62430     } catch (...) {
62431       {
62432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62433       };
62434     }
62435   }
62436
62437   jresult = (void *)result;
62438   return jresult;
62439 }
62440
62441
62442 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62443   unsigned long jresult ;
62444   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62445   size_t result;
62446
62447   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62448   {
62449     try {
62450       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62451     } catch (std::out_of_range& e) {
62452       {
62453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62454       };
62455     } catch (std::exception& e) {
62456       {
62457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62458       };
62459     } catch (Dali::DaliException e) {
62460       {
62461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62462       };
62463     } catch (...) {
62464       {
62465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62466       };
62467     }
62468   }
62469
62470   jresult = (unsigned long)result;
62471   return jresult;
62472 }
62473
62474
62475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62476   void * jresult ;
62477   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62478   size_t arg2 ;
62479   Dali::Property::Map result;
62480
62481   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62482   arg2 = (size_t)jarg2;
62483   {
62484     try {
62485       result = (arg1)->GetAnimatorAt(arg2);
62486     } catch (std::out_of_range& e) {
62487       {
62488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62489       };
62490     } catch (std::exception& e) {
62491       {
62492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62493       };
62494     } catch (Dali::DaliException e) {
62495       {
62496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62497       };
62498     } catch (...) {
62499       {
62500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62501       };
62502     }
62503   }
62504
62505   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62506   return jresult;
62507 }
62508
62509
62510 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62511   int jresult ;
62512   int result;
62513
62514   {
62515     try {
62516       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62517     } catch (std::out_of_range& e) {
62518       {
62519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62520       };
62521     } catch (std::exception& e) {
62522       {
62523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62524       };
62525     } catch (Dali::DaliException e) {
62526       {
62527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62528       };
62529     } catch (...) {
62530       {
62531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62532       };
62533     }
62534   }
62535
62536   jresult = (int)result;
62537   return jresult;
62538 }
62539
62540
62541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62542   int jresult ;
62543   int result;
62544
62545   {
62546     try {
62547       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62548     } catch (std::out_of_range& e) {
62549       {
62550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62551       };
62552     } catch (std::exception& e) {
62553       {
62554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62555       };
62556     } catch (Dali::DaliException e) {
62557       {
62558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62559       };
62560     } catch (...) {
62561       {
62562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62563       };
62564     }
62565   }
62566
62567   jresult = (int)result;
62568   return jresult;
62569 }
62570
62571
62572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62573   int jresult ;
62574   int result;
62575
62576   {
62577     try {
62578       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62579     } catch (std::out_of_range& e) {
62580       {
62581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62582       };
62583     } catch (std::exception& e) {
62584       {
62585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62586       };
62587     } catch (Dali::DaliException e) {
62588       {
62589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62590       };
62591     } catch (...) {
62592       {
62593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62594       };
62595     }
62596   }
62597
62598   jresult = (int)result;
62599   return jresult;
62600 }
62601
62602
62603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62604   int jresult ;
62605   int result;
62606
62607   {
62608     try {
62609       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62610     } catch (std::out_of_range& e) {
62611       {
62612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62613       };
62614     } catch (std::exception& e) {
62615       {
62616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62617       };
62618     } catch (Dali::DaliException e) {
62619       {
62620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62621       };
62622     } catch (...) {
62623       {
62624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62625       };
62626     }
62627   }
62628
62629   jresult = (int)result;
62630   return jresult;
62631 }
62632
62633
62634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62635   int jresult ;
62636   int result;
62637
62638   {
62639     try {
62640       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62641     } catch (std::out_of_range& e) {
62642       {
62643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62644       };
62645     } catch (std::exception& e) {
62646       {
62647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62648       };
62649     } catch (Dali::DaliException e) {
62650       {
62651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62652       };
62653     } catch (...) {
62654       {
62655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62656       };
62657     }
62658   }
62659
62660   jresult = (int)result;
62661   return jresult;
62662 }
62663
62664
62665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62666   int jresult ;
62667   int result;
62668
62669   {
62670     try {
62671       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62672     } catch (std::out_of_range& e) {
62673       {
62674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62675       };
62676     } catch (std::exception& e) {
62677       {
62678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62679       };
62680     } catch (Dali::DaliException e) {
62681       {
62682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62683       };
62684     } catch (...) {
62685       {
62686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62687       };
62688     }
62689   }
62690
62691   jresult = (int)result;
62692   return jresult;
62693 }
62694
62695
62696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62697   int jresult ;
62698   int result;
62699
62700   {
62701     try {
62702       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62703     } catch (std::out_of_range& e) {
62704       {
62705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62706       };
62707     } catch (std::exception& e) {
62708       {
62709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62710       };
62711     } catch (Dali::DaliException e) {
62712       {
62713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62714       };
62715     } catch (...) {
62716       {
62717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62718       };
62719     }
62720   }
62721
62722   jresult = (int)result;
62723   return jresult;
62724 }
62725
62726
62727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62728   int jresult ;
62729   int result;
62730
62731   {
62732     try {
62733       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62734     } catch (std::out_of_range& e) {
62735       {
62736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62737       };
62738     } catch (std::exception& e) {
62739       {
62740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62741       };
62742     } catch (Dali::DaliException e) {
62743       {
62744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62745       };
62746     } catch (...) {
62747       {
62748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62749       };
62750     }
62751   }
62752
62753   jresult = (int)result;
62754   return jresult;
62755 }
62756
62757
62758 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62759   int jresult ;
62760   int result;
62761
62762   {
62763     try {
62764       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62765     } catch (std::out_of_range& e) {
62766       {
62767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62768       };
62769     } catch (std::exception& e) {
62770       {
62771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62772       };
62773     } catch (Dali::DaliException e) {
62774       {
62775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62776       };
62777     } catch (...) {
62778       {
62779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62780       };
62781     }
62782   }
62783
62784   jresult = (int)result;
62785   return jresult;
62786 }
62787
62788
62789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62790   int jresult ;
62791   int result;
62792
62793   {
62794     try {
62795       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62796     } catch (std::out_of_range& e) {
62797       {
62798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62799       };
62800     } catch (std::exception& e) {
62801       {
62802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62803       };
62804     } catch (Dali::DaliException e) {
62805       {
62806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62807       };
62808     } catch (...) {
62809       {
62810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62811       };
62812     }
62813   }
62814
62815   jresult = (int)result;
62816   return jresult;
62817 }
62818
62819
62820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62821   int jresult ;
62822   int result;
62823
62824   {
62825     try {
62826       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62827     } catch (std::out_of_range& e) {
62828       {
62829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62830       };
62831     } catch (std::exception& e) {
62832       {
62833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62834       };
62835     } catch (Dali::DaliException e) {
62836       {
62837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62838       };
62839     } catch (...) {
62840       {
62841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62842       };
62843     }
62844   }
62845
62846   jresult = (int)result;
62847   return jresult;
62848 }
62849
62850
62851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62852   int jresult ;
62853   int result;
62854
62855   {
62856     try {
62857       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62858     } catch (std::out_of_range& e) {
62859       {
62860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62861       };
62862     } catch (std::exception& e) {
62863       {
62864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62865       };
62866     } catch (Dali::DaliException e) {
62867       {
62868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62869       };
62870     } catch (...) {
62871       {
62872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62873       };
62874     }
62875   }
62876
62877   jresult = (int)result;
62878   return jresult;
62879 }
62880
62881
62882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62883   int jresult ;
62884   int result;
62885
62886   {
62887     try {
62888       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62889     } catch (std::out_of_range& e) {
62890       {
62891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62892       };
62893     } catch (std::exception& e) {
62894       {
62895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62896       };
62897     } catch (Dali::DaliException e) {
62898       {
62899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62900       };
62901     } catch (...) {
62902       {
62903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62904       };
62905     }
62906   }
62907
62908   jresult = (int)result;
62909   return jresult;
62910 }
62911
62912
62913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62914   int jresult ;
62915   int result;
62916
62917   {
62918     try {
62919       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62920     } catch (std::out_of_range& e) {
62921       {
62922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62923       };
62924     } catch (std::exception& e) {
62925       {
62926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62927       };
62928     } catch (Dali::DaliException e) {
62929       {
62930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62931       };
62932     } catch (...) {
62933       {
62934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62935       };
62936     }
62937   }
62938
62939   jresult = (int)result;
62940   return jresult;
62941 }
62942
62943
62944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62945   void * jresult ;
62946   Dali::Toolkit::Control result;
62947
62948   {
62949     try {
62950       result = Dali::Toolkit::Internal::Control::New();
62951     } catch (std::out_of_range& e) {
62952       {
62953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62954       };
62955     } catch (std::exception& e) {
62956       {
62957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62958       };
62959     } catch (Dali::DaliException e) {
62960       {
62961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62962       };
62963     } catch (...) {
62964       {
62965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62966       };
62967     }
62968   }
62969
62970   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62971   return jresult;
62972 }
62973
62974
62975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
62976   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62977   std::string *arg2 = 0 ;
62978
62979   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62980   if (!jarg2) {
62981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62982     return ;
62983   }
62984   std::string arg2_str(jarg2);
62985   arg2 = &arg2_str;
62986   {
62987     try {
62988       (arg1)->SetStyleName((std::string const &)*arg2);
62989     } catch (std::out_of_range& e) {
62990       {
62991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62992       };
62993     } catch (std::exception& e) {
62994       {
62995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62996       };
62997     } catch (Dali::DaliException e) {
62998       {
62999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63000       };
63001     } catch (...) {
63002       {
63003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63004       };
63005     }
63006   }
63007
63008
63009   //argout typemap for const std::string&
63010
63011 }
63012
63013
63014 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
63015   char * jresult ;
63016   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63017   std::string *result = 0 ;
63018
63019   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63020   {
63021     try {
63022       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
63023     } catch (std::out_of_range& e) {
63024       {
63025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63026       };
63027     } catch (std::exception& e) {
63028       {
63029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63030       };
63031     } catch (Dali::DaliException e) {
63032       {
63033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63034       };
63035     } catch (...) {
63036       {
63037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63038       };
63039     }
63040   }
63041
63042   jresult = SWIG_csharp_string_callback(result->c_str());
63043   return jresult;
63044 }
63045
63046
63047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63048   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63049   Dali::Vector4 *arg2 = 0 ;
63050
63051   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63052   arg2 = (Dali::Vector4 *)jarg2;
63053   if (!arg2) {
63054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63055     return ;
63056   }
63057   {
63058     try {
63059       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63060     } catch (std::out_of_range& e) {
63061       {
63062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63063       };
63064     } catch (std::exception& e) {
63065       {
63066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63067       };
63068     } catch (Dali::DaliException e) {
63069       {
63070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63071       };
63072     } catch (...) {
63073       {
63074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63075       };
63076     }
63077   }
63078
63079 }
63080
63081
63082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63083   void * jresult ;
63084   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63085   Dali::Vector4 result;
63086
63087   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63088   {
63089     try {
63090       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63091     } catch (std::out_of_range& e) {
63092       {
63093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63094       };
63095     } catch (std::exception& e) {
63096       {
63097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63098       };
63099     } catch (Dali::DaliException e) {
63100       {
63101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63102       };
63103     } catch (...) {
63104       {
63105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63106       };
63107     }
63108   }
63109
63110   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63111   return jresult;
63112 }
63113
63114
63115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63116   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63117   Dali::Image arg2 ;
63118   Dali::Image *argp2 ;
63119
63120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63121   argp2 = (Dali::Image *)jarg2;
63122   if (!argp2) {
63123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63124     return ;
63125   }
63126   arg2 = *argp2;
63127   {
63128     try {
63129       (arg1)->SetBackgroundImage(arg2);
63130     } catch (std::out_of_range& e) {
63131       {
63132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63133       };
63134     } catch (std::exception& e) {
63135       {
63136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63137       };
63138     } catch (Dali::DaliException e) {
63139       {
63140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63141       };
63142     } catch (...) {
63143       {
63144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63145       };
63146     }
63147   }
63148
63149 }
63150
63151
63152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63153   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63154   Dali::Property::Map *arg2 = 0 ;
63155
63156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63157   arg2 = (Dali::Property::Map *)jarg2;
63158   if (!arg2) {
63159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63160     return ;
63161   }
63162   {
63163     try {
63164       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63165     } catch (std::out_of_range& e) {
63166       {
63167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63168       };
63169     } catch (std::exception& e) {
63170       {
63171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63172       };
63173     } catch (Dali::DaliException e) {
63174       {
63175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63176       };
63177     } catch (...) {
63178       {
63179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63180       };
63181     }
63182   }
63183
63184 }
63185
63186
63187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63189
63190   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63191   {
63192     try {
63193       (arg1)->ClearBackground();
63194     } catch (std::out_of_range& e) {
63195       {
63196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63197       };
63198     } catch (std::exception& e) {
63199       {
63200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63201       };
63202     } catch (Dali::DaliException e) {
63203       {
63204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63205       };
63206     } catch (...) {
63207       {
63208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63209       };
63210     }
63211   }
63212
63213 }
63214
63215
63216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63217   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63218   Dali::Gesture::Type arg2 ;
63219
63220   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63221   arg2 = (Dali::Gesture::Type)jarg2;
63222   {
63223     try {
63224       (arg1)->EnableGestureDetection(arg2);
63225     } catch (std::out_of_range& e) {
63226       {
63227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63228       };
63229     } catch (std::exception& e) {
63230       {
63231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63232       };
63233     } catch (Dali::DaliException e) {
63234       {
63235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63236       };
63237     } catch (...) {
63238       {
63239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63240       };
63241     }
63242   }
63243
63244 }
63245
63246
63247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63248   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63249   Dali::Gesture::Type arg2 ;
63250
63251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63252   arg2 = (Dali::Gesture::Type)jarg2;
63253   {
63254     try {
63255       (arg1)->DisableGestureDetection(arg2);
63256     } catch (std::out_of_range& e) {
63257       {
63258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63259       };
63260     } catch (std::exception& e) {
63261       {
63262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63263       };
63264     } catch (Dali::DaliException e) {
63265       {
63266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63267       };
63268     } catch (...) {
63269       {
63270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63271       };
63272     }
63273   }
63274
63275 }
63276
63277
63278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63279   void * jresult ;
63280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63281   Dali::PinchGestureDetector result;
63282
63283   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63284   {
63285     try {
63286       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63287     } catch (std::out_of_range& e) {
63288       {
63289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63290       };
63291     } catch (std::exception& e) {
63292       {
63293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63294       };
63295     } catch (Dali::DaliException e) {
63296       {
63297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63298       };
63299     } catch (...) {
63300       {
63301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63302       };
63303     }
63304   }
63305
63306   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63307   return jresult;
63308 }
63309
63310
63311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63312   void * jresult ;
63313   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63314   Dali::PanGestureDetector result;
63315
63316   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63317   {
63318     try {
63319       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63320     } catch (std::out_of_range& e) {
63321       {
63322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63323       };
63324     } catch (std::exception& e) {
63325       {
63326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63327       };
63328     } catch (Dali::DaliException e) {
63329       {
63330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63331       };
63332     } catch (...) {
63333       {
63334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63335       };
63336     }
63337   }
63338
63339   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63340   return jresult;
63341 }
63342
63343
63344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63345   void * jresult ;
63346   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63347   Dali::TapGestureDetector result;
63348
63349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63350   {
63351     try {
63352       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63353     } catch (std::out_of_range& e) {
63354       {
63355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63356       };
63357     } catch (std::exception& e) {
63358       {
63359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63360       };
63361     } catch (Dali::DaliException e) {
63362       {
63363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63364       };
63365     } catch (...) {
63366       {
63367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63368       };
63369     }
63370   }
63371
63372   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63373   return jresult;
63374 }
63375
63376
63377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63378   void * jresult ;
63379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63380   Dali::LongPressGestureDetector result;
63381
63382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63383   {
63384     try {
63385       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63386     } catch (std::out_of_range& e) {
63387       {
63388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63389       };
63390     } catch (std::exception& e) {
63391       {
63392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63393       };
63394     } catch (Dali::DaliException e) {
63395       {
63396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63397       };
63398     } catch (...) {
63399       {
63400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63401       };
63402     }
63403   }
63404
63405   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63406   return jresult;
63407 }
63408
63409
63410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63411   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63412   bool arg2 ;
63413
63414   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63415   arg2 = jarg2 ? true : false;
63416   {
63417     try {
63418       (arg1)->SetKeyboardNavigationSupport(arg2);
63419     } catch (std::out_of_range& e) {
63420       {
63421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63422       };
63423     } catch (std::exception& e) {
63424       {
63425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63426       };
63427     } catch (Dali::DaliException e) {
63428       {
63429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63430       };
63431     } catch (...) {
63432       {
63433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63434       };
63435     }
63436   }
63437
63438 }
63439
63440
63441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63442   unsigned int jresult ;
63443   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63444   bool result;
63445
63446   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63447   {
63448     try {
63449       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63450     } catch (std::out_of_range& e) {
63451       {
63452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63453       };
63454     } catch (std::exception& e) {
63455       {
63456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63457       };
63458     } catch (Dali::DaliException e) {
63459       {
63460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63461       };
63462     } catch (...) {
63463       {
63464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63465       };
63466     }
63467   }
63468
63469   jresult = result;
63470   return jresult;
63471 }
63472
63473
63474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63475   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63476
63477   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63478   {
63479     try {
63480       (arg1)->SetKeyInputFocus();
63481     } catch (std::out_of_range& e) {
63482       {
63483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63484       };
63485     } catch (std::exception& e) {
63486       {
63487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63488       };
63489     } catch (Dali::DaliException e) {
63490       {
63491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63492       };
63493     } catch (...) {
63494       {
63495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63496       };
63497     }
63498   }
63499
63500 }
63501
63502
63503 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63504   unsigned int jresult ;
63505   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63506   bool result;
63507
63508   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63509   {
63510     try {
63511       result = (bool)(arg1)->HasKeyInputFocus();
63512     } catch (std::out_of_range& e) {
63513       {
63514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63515       };
63516     } catch (std::exception& e) {
63517       {
63518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63519       };
63520     } catch (Dali::DaliException e) {
63521       {
63522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63523       };
63524     } catch (...) {
63525       {
63526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63527       };
63528     }
63529   }
63530
63531   jresult = result;
63532   return jresult;
63533 }
63534
63535
63536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63537   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63538
63539   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63540   {
63541     try {
63542       (arg1)->ClearKeyInputFocus();
63543     } catch (std::out_of_range& e) {
63544       {
63545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63546       };
63547     } catch (std::exception& e) {
63548       {
63549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63550       };
63551     } catch (Dali::DaliException e) {
63552       {
63553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63554       };
63555     } catch (...) {
63556       {
63557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63558       };
63559     }
63560   }
63561
63562 }
63563
63564
63565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63566   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63567   bool arg2 ;
63568
63569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63570   arg2 = jarg2 ? true : false;
63571   {
63572     try {
63573       (arg1)->SetAsKeyboardFocusGroup(arg2);
63574     } catch (std::out_of_range& e) {
63575       {
63576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63577       };
63578     } catch (std::exception& e) {
63579       {
63580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63581       };
63582     } catch (Dali::DaliException e) {
63583       {
63584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63585       };
63586     } catch (...) {
63587       {
63588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63589       };
63590     }
63591   }
63592
63593 }
63594
63595
63596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63597   unsigned int jresult ;
63598   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63599   bool result;
63600
63601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63602   {
63603     try {
63604       result = (bool)(arg1)->IsKeyboardFocusGroup();
63605     } catch (std::out_of_range& e) {
63606       {
63607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63608       };
63609     } catch (std::exception& e) {
63610       {
63611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63612       };
63613     } catch (Dali::DaliException e) {
63614       {
63615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63616       };
63617     } catch (...) {
63618       {
63619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63620       };
63621     }
63622   }
63623
63624   jresult = result;
63625   return jresult;
63626 }
63627
63628
63629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63630   void * jresult ;
63631   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63632   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63633
63634   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63635   {
63636     try {
63637       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63638     } catch (std::out_of_range& e) {
63639       {
63640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63641       };
63642     } catch (std::exception& e) {
63643       {
63644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63645       };
63646     } catch (Dali::DaliException e) {
63647       {
63648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63649       };
63650     } catch (...) {
63651       {
63652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63653       };
63654     }
63655   }
63656
63657   jresult = (void *)result;
63658   return jresult;
63659 }
63660
63661
63662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63663   void * jresult ;
63664   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63665   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63666
63667   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63668   {
63669     try {
63670       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63671     } catch (std::out_of_range& e) {
63672       {
63673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63674       };
63675     } catch (std::exception& e) {
63676       {
63677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63678       };
63679     } catch (Dali::DaliException e) {
63680       {
63681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63682       };
63683     } catch (...) {
63684       {
63685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63686       };
63687     }
63688   }
63689
63690   jresult = (void *)result;
63691   return jresult;
63692 }
63693
63694
63695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63696   void * jresult ;
63697   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63698   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63699
63700   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63701   {
63702     try {
63703       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63704     } catch (std::out_of_range& e) {
63705       {
63706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63707       };
63708     } catch (std::exception& e) {
63709       {
63710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63711       };
63712     } catch (Dali::DaliException e) {
63713       {
63714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63715       };
63716     } catch (...) {
63717       {
63718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63719       };
63720     }
63721   }
63722
63723   jresult = (void *)result;
63724   return jresult;
63725 }
63726
63727
63728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63729   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63730   int arg2 ;
63731   SwigDirector_ViewImpl *darg = 0;
63732
63733   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63734   arg2 = (int)jarg2;
63735   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63736   if(!darg) {
63737     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63738     return;
63739   }
63740   {
63741     try {
63742       if(darg) {
63743         (darg)->OnStageConnection(arg2);
63744       }
63745     } catch (std::out_of_range& e) {
63746       {
63747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63748       };
63749     } catch (std::exception& e) {
63750       {
63751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63752       };
63753     } catch (Dali::DaliException e) {
63754       {
63755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63756       };
63757     } catch (...) {
63758       {
63759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63760       };
63761     }
63762   }
63763
63764 }
63765
63766
63767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
63768   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63769   int arg2 ;
63770   SwigDirector_ViewImpl *darg = 0;
63771
63772   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63773   arg2 = (int)jarg2;
63774   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63775   if(!darg) {
63776     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63777     return;
63778   }
63779   {
63780     try {
63781       if(darg) {
63782         (darg)->OnStageConnectionSwigPublic(arg2);
63783       }
63784     } catch (std::out_of_range& e) {
63785       {
63786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63787       };
63788     } catch (std::exception& e) {
63789       {
63790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63791       };
63792     } catch (Dali::DaliException e) {
63793       {
63794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63795       };
63796     } catch (...) {
63797       {
63798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63799       };
63800     }
63801   }
63802
63803 }
63804
63805
63806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
63807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63808   SwigDirector_ViewImpl *darg = 0;
63809
63810   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63811   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63812   if(!darg) {
63813     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63814     return;
63815   }
63816   {
63817     try {
63818       if(darg) {
63819         (darg)->OnStageDisconnection();
63820       }
63821     } catch (std::out_of_range& e) {
63822       {
63823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63824       };
63825     } catch (std::exception& e) {
63826       {
63827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63828       };
63829     } catch (Dali::DaliException e) {
63830       {
63831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63832       };
63833     } catch (...) {
63834       {
63835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63836       };
63837     }
63838   }
63839
63840 }
63841
63842
63843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63845   SwigDirector_ViewImpl *darg = 0;
63846
63847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63848   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63849   if(!darg) {
63850     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63851     return;
63852   }
63853   {
63854     try {
63855       if(darg) {
63856         (darg)->OnStageDisconnectionSwigPublic();
63857       }
63858     } catch (std::out_of_range& e) {
63859       {
63860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63861       };
63862     } catch (std::exception& e) {
63863       {
63864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63865       };
63866     } catch (Dali::DaliException e) {
63867       {
63868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63869       };
63870     } catch (...) {
63871       {
63872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63873       };
63874     }
63875   }
63876
63877 }
63878
63879
63880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63881   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63882   Dali::Actor *arg2 = 0 ;
63883   SwigDirector_ViewImpl *darg = 0;
63884
63885   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63886   arg2 = (Dali::Actor *)jarg2;
63887   if (!arg2) {
63888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63889     return ;
63890   }
63891   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63892   if(!darg) {
63893     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63894     return;
63895   }
63896   {
63897     try {
63898       if(darg) {
63899         (darg)->OnChildAdd(*arg2);
63900       }
63901     } catch (std::out_of_range& e) {
63902       {
63903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63904       };
63905     } catch (std::exception& e) {
63906       {
63907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63908       };
63909     } catch (Dali::DaliException e) {
63910       {
63911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63912       };
63913     } catch (...) {
63914       {
63915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63916       };
63917     }
63918   }
63919
63920 }
63921
63922
63923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63924   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63925   Dali::Actor *arg2 = 0 ;
63926   SwigDirector_ViewImpl *darg = 0;
63927
63928   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63929   arg2 = (Dali::Actor *)jarg2;
63930   if (!arg2) {
63931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63932     return ;
63933   }
63934   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63935   if(!darg) {
63936     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63937     return;
63938   }
63939   {
63940     try {
63941       if(darg) {
63942           (darg)->OnChildAddSwigPublic(*arg2);
63943       }
63944     } catch (std::out_of_range& e) {
63945       {
63946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63947       };
63948     } catch (std::exception& e) {
63949       {
63950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63951       };
63952     } catch (Dali::DaliException e) {
63953       {
63954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63955       };
63956     } catch (...) {
63957       {
63958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63959       };
63960     }
63961   }
63962
63963 }
63964
63965
63966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
63967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63968   Dali::Actor *arg2 = 0 ;
63969   SwigDirector_ViewImpl *darg = 0;
63970
63971   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63972   arg2 = (Dali::Actor *)jarg2;
63973   if (!arg2) {
63974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63975     return ;
63976   }
63977   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63978   if(!darg) {
63979     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63980     return;
63981   }
63982   {
63983     try {
63984       if(darg) {
63985         (darg)->OnChildRemove(*arg2);
63986       }
63987     } catch (std::out_of_range& e) {
63988       {
63989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63990       };
63991     } catch (std::exception& e) {
63992       {
63993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63994       };
63995     } catch (Dali::DaliException e) {
63996       {
63997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63998       };
63999     } catch (...) {
64000       {
64001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64002       };
64003     }
64004   }
64005
64006 }
64007
64008
64009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64011   Dali::Actor *arg2 = 0 ;
64012   SwigDirector_ViewImpl *darg = 0;
64013
64014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64015   arg2 = (Dali::Actor *)jarg2;
64016   if (!arg2) {
64017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64018     return ;
64019   }
64020   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64021   if(!darg) {
64022     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64023     return;
64024   }
64025   {
64026     try {
64027       if(darg) {
64028         (darg)->OnChildRemoveSwigPublic(*arg2);
64029       }
64030     } catch (std::out_of_range& e) {
64031       {
64032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64033       };
64034     } catch (std::exception& e) {
64035       {
64036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64037       };
64038     } catch (Dali::DaliException e) {
64039       {
64040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64041       };
64042     } catch (...) {
64043       {
64044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64045       };
64046     }
64047   }
64048
64049 }
64050
64051
64052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64053   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64054   Dali::Property::Index arg2 ;
64055   Dali::Property::Value arg3 ;
64056   Dali::Property::Value *argp3 ;
64057   SwigDirector_ViewImpl *darg = 0;
64058
64059   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64060   arg2 = (Dali::Property::Index)jarg2;
64061   argp3 = (Dali::Property::Value *)jarg3;
64062   if (!argp3) {
64063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64064     return ;
64065   }
64066   arg3 = *argp3;
64067   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64068   if (!darg) {
64069     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64070     return;
64071   }
64072   {
64073     try {
64074       (darg)->OnPropertySet(arg2,arg3);
64075     } catch (std::out_of_range& e) {
64076       {
64077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64078       };
64079     } catch (std::exception& e) {
64080       {
64081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64082       };
64083     } catch (Dali::DaliException e) {
64084       {
64085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64086       };
64087     } catch (...) {
64088       {
64089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64090       };
64091     }
64092   }
64093
64094 }
64095
64096
64097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64099   Dali::Property::Index arg2 ;
64100   Dali::Property::Value arg3 ;
64101   Dali::Property::Value *argp3 ;
64102   SwigDirector_ViewImpl *darg = 0;
64103
64104   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64105   arg2 = (Dali::Property::Index)jarg2;
64106   argp3 = (Dali::Property::Value *)jarg3;
64107   if (!argp3) {
64108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64109     return ;
64110   }
64111   arg3 = *argp3;
64112   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64113   if (!darg) {
64114     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64115     return;
64116   }
64117   {
64118     try {
64119       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64120     } catch (std::out_of_range& e) {
64121       {
64122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64123       };
64124     } catch (std::exception& e) {
64125       {
64126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64127       };
64128     } catch (Dali::DaliException e) {
64129       {
64130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64131       };
64132     } catch (...) {
64133       {
64134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64135       };
64136     }
64137   }
64138
64139 }
64140
64141
64142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64144   Dali::Vector3 *arg2 = 0 ;
64145   SwigDirector_ViewImpl *darg = 0;
64146
64147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64148   arg2 = (Dali::Vector3 *)jarg2;
64149   if (!arg2) {
64150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64151     return ;
64152   }
64153   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64154   if (!darg) {
64155     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64156     return;
64157   }
64158   {
64159     try {
64160       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64161     } catch (std::out_of_range& e) {
64162       {
64163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64164       };
64165     } catch (std::exception& e) {
64166       {
64167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64168       };
64169     } catch (Dali::DaliException e) {
64170       {
64171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64172       };
64173     } catch (...) {
64174       {
64175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64176       };
64177     }
64178   }
64179
64180 }
64181
64182
64183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64184   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64185   Dali::Vector3 *arg2 = 0 ;
64186   SwigDirector_ViewImpl *darg = 0;
64187
64188   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64189   arg2 = (Dali::Vector3 *)jarg2;
64190   if (!arg2) {
64191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64192     return ;
64193   }
64194   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64195   if (!darg) {
64196     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64197     return;
64198   }
64199   {
64200     try {
64201       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64202     } catch (std::out_of_range& e) {
64203       {
64204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64205       };
64206     } catch (std::exception& e) {
64207       {
64208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64209       };
64210     } catch (Dali::DaliException e) {
64211       {
64212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64213       };
64214     } catch (...) {
64215       {
64216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64217       };
64218     }
64219   }
64220
64221 }
64222
64223
64224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64225   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64226   Dali::Animation *arg2 = 0 ;
64227   Dali::Vector3 *arg3 = 0 ;
64228   SwigDirector_ViewImpl *darg = 0;
64229
64230   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64231   arg2 = (Dali::Animation *)jarg2;
64232   if (!arg2) {
64233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64234     return ;
64235   }
64236   arg3 = (Dali::Vector3 *)jarg3;
64237   if (!arg3) {
64238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64239     return ;
64240   }
64241   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64242   if (!darg) {
64243     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64244     return;
64245   }
64246   {
64247     try {
64248       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64249     } catch (std::out_of_range& e) {
64250       {
64251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64252       };
64253     } catch (std::exception& e) {
64254       {
64255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64256       };
64257     } catch (Dali::DaliException e) {
64258       {
64259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64260       };
64261     } catch (...) {
64262       {
64263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64264       };
64265     }
64266   }
64267
64268 }
64269
64270
64271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64272   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64273   Dali::Animation *arg2 = 0 ;
64274   Dali::Vector3 *arg3 = 0 ;
64275   SwigDirector_ViewImpl *darg = 0;
64276
64277   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64278   arg2 = (Dali::Animation *)jarg2;
64279   if (!arg2) {
64280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64281     return ;
64282   }
64283   arg3 = (Dali::Vector3 *)jarg3;
64284   if (!arg3) {
64285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64286     return ;
64287   }
64288   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64289   if (!darg) {
64290     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64291     return;
64292   }
64293   {
64294     try {
64295       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64296     } catch (std::out_of_range& e) {
64297       {
64298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64299       };
64300     } catch (std::exception& e) {
64301       {
64302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64303       };
64304     } catch (Dali::DaliException e) {
64305       {
64306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64307       };
64308     } catch (...) {
64309       {
64310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64311       };
64312     }
64313   }
64314
64315 }
64316
64317
64318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64319   unsigned int jresult ;
64320   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64321   Dali::TouchEvent *arg2 = 0 ;
64322   SwigDirector_ViewImpl *darg = 0;
64323   bool result;
64324
64325   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64326   arg2 = (Dali::TouchEvent *)jarg2;
64327   if (!arg2) {
64328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64329     return 0;
64330   }
64331   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64332   if (!darg) {
64333     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64334     return 0;
64335   }
64336   {
64337     try {
64338       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64339     } catch (std::out_of_range& e) {
64340       {
64341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64342       };
64343     } catch (std::exception& e) {
64344       {
64345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64346       };
64347     } catch (Dali::DaliException e) {
64348       {
64349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64350       };
64351     } catch (...) {
64352       {
64353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64354       };
64355     }
64356   }
64357
64358   jresult = result;
64359   return jresult;
64360 }
64361
64362
64363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64364   unsigned int jresult ;
64365   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64366   Dali::TouchEvent *arg2 = 0 ;
64367   SwigDirector_ViewImpl *darg = 0;
64368   bool result;
64369
64370   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64371   arg2 = (Dali::TouchEvent *)jarg2;
64372   if (!arg2) {
64373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64374     return 0;
64375   }
64376   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64377   if (!darg) {
64378     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64379     return 0;
64380   }
64381   {
64382     try {
64383       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64384     } catch (std::out_of_range& e) {
64385       {
64386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64387       };
64388     } catch (std::exception& e) {
64389       {
64390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64391       };
64392     } catch (Dali::DaliException e) {
64393       {
64394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64395       };
64396     } catch (...) {
64397       {
64398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64399       };
64400     }
64401   }
64402
64403   jresult = result;
64404   return jresult;
64405 }
64406
64407
64408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64409   unsigned int jresult ;
64410   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64411   Dali::HoverEvent *arg2 = 0 ;
64412   SwigDirector_ViewImpl *darg = 0;
64413   bool result;
64414
64415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64416   arg2 = (Dali::HoverEvent *)jarg2;
64417   if (!arg2) {
64418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64419     return 0;
64420   }
64421   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64422   if (!darg) {
64423     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64424     return 0;
64425   }
64426   {
64427     try {
64428       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64429     } catch (std::out_of_range& e) {
64430       {
64431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64432       };
64433     } catch (std::exception& e) {
64434       {
64435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64436       };
64437     } catch (Dali::DaliException e) {
64438       {
64439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64440       };
64441     } catch (...) {
64442       {
64443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64444       };
64445     }
64446   }
64447
64448   jresult = result;
64449   return jresult;
64450 }
64451
64452
64453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64454   unsigned int jresult ;
64455   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64456   Dali::HoverEvent *arg2 = 0 ;
64457   SwigDirector_ViewImpl *darg = 0;
64458   bool result;
64459
64460   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64461   arg2 = (Dali::HoverEvent *)jarg2;
64462   if (!arg2) {
64463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64464     return 0;
64465   }
64466   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64467   if (!darg) {
64468     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64469     return 0;
64470   }
64471   {
64472     try {
64473       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64474     } catch (std::out_of_range& e) {
64475       {
64476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64477       };
64478     } catch (std::exception& e) {
64479       {
64480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64481       };
64482     } catch (Dali::DaliException e) {
64483       {
64484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64485       };
64486     } catch (...) {
64487       {
64488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64489       };
64490     }
64491   }
64492
64493   jresult = result;
64494   return jresult;
64495 }
64496
64497
64498 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64499   unsigned int jresult ;
64500   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64501   Dali::KeyEvent *arg2 = 0 ;
64502   SwigDirector_ViewImpl *darg = 0;
64503   bool result;
64504
64505   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64506   arg2 = (Dali::KeyEvent *)jarg2;
64507   if (!arg2) {
64508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64509     return 0;
64510   }
64511   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64512   if (!darg) {
64513     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64514     return 0;
64515   }
64516   {
64517     try {
64518       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64519     } catch (std::out_of_range& e) {
64520       {
64521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64522       };
64523     } catch (std::exception& e) {
64524       {
64525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64526       };
64527     } catch (Dali::DaliException e) {
64528       {
64529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64530       };
64531     } catch (...) {
64532       {
64533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64534       };
64535     }
64536   }
64537
64538   jresult = result;
64539   return jresult;
64540 }
64541
64542
64543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64544   unsigned int jresult ;
64545   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64546   Dali::KeyEvent *arg2 = 0 ;
64547   SwigDirector_ViewImpl *darg = 0;
64548   bool result;
64549
64550   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64551   arg2 = (Dali::KeyEvent *)jarg2;
64552   if (!arg2) {
64553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64554     return 0;
64555   }
64556   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64557   if (!darg) {
64558     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64559     return 0;
64560   }
64561   {
64562     try {
64563       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64564     } catch (std::out_of_range& e) {
64565       {
64566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64567       };
64568     } catch (std::exception& e) {
64569       {
64570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64571       };
64572     } catch (Dali::DaliException e) {
64573       {
64574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64575       };
64576     } catch (...) {
64577       {
64578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64579       };
64580     }
64581   }
64582
64583   jresult = result;
64584   return jresult;
64585 }
64586
64587
64588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64589   unsigned int jresult ;
64590   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64591   Dali::WheelEvent *arg2 = 0 ;
64592   SwigDirector_ViewImpl *darg = 0;
64593   bool result;
64594
64595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64596   arg2 = (Dali::WheelEvent *)jarg2;
64597   if (!arg2) {
64598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64599     return 0;
64600   }
64601   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64602   if (!darg) {
64603     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64604     return 0;
64605   }
64606   {
64607     try {
64608       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64609     } catch (std::out_of_range& e) {
64610       {
64611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64612       };
64613     } catch (std::exception& e) {
64614       {
64615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64616       };
64617     } catch (Dali::DaliException e) {
64618       {
64619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64620       };
64621     } catch (...) {
64622       {
64623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64624       };
64625     }
64626   }
64627
64628   jresult = result;
64629   return jresult;
64630 }
64631
64632
64633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64634   unsigned int jresult ;
64635   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64636   Dali::WheelEvent *arg2 = 0 ;
64637   SwigDirector_ViewImpl *darg = 0;
64638   bool result;
64639
64640   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64641   arg2 = (Dali::WheelEvent *)jarg2;
64642   if (!arg2) {
64643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64644     return 0;
64645   }
64646   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64647   if (!darg) {
64648     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64649     return 0;
64650   }
64651   {
64652     try {
64653       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64654     } catch (std::out_of_range& e) {
64655       {
64656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64657       };
64658     } catch (std::exception& e) {
64659       {
64660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64661       };
64662     } catch (Dali::DaliException e) {
64663       {
64664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64665       };
64666     } catch (...) {
64667       {
64668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64669       };
64670     }
64671   }
64672
64673   jresult = result;
64674   return jresult;
64675 }
64676
64677
64678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64679   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64680   Dali::Vector2 *arg2 = 0 ;
64681   Dali::RelayoutContainer *arg3 = 0 ;
64682   SwigDirector_ViewImpl *darg = 0;
64683
64684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64685   arg2 = (Dali::Vector2 *)jarg2;
64686   if (!arg2) {
64687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64688     return ;
64689   }
64690   arg3 = (Dali::RelayoutContainer *)jarg3;
64691   if (!arg3) {
64692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64693     return ;
64694   }
64695   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64696   if (!darg) {
64697     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64698     return;
64699   }
64700   {
64701     try {
64702       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64703     } catch (std::out_of_range& e) {
64704       {
64705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64706       };
64707     } catch (std::exception& e) {
64708       {
64709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64710       };
64711     } catch (Dali::DaliException e) {
64712       {
64713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64714       };
64715     } catch (...) {
64716       {
64717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64718       };
64719     }
64720   }
64721
64722 }
64723
64724
64725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64726   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64727   Dali::Vector2 *arg2 = 0 ;
64728   Dali::RelayoutContainer *arg3 = 0 ;
64729   SwigDirector_ViewImpl *darg = 0;
64730
64731   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64732   arg2 = (Dali::Vector2 *)jarg2;
64733   if (!arg2) {
64734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64735     return ;
64736   }
64737   arg3 = (Dali::RelayoutContainer *)jarg3;
64738   if (!arg3) {
64739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64740     return ;
64741   }
64742   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64743   if (!darg) {
64744     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64745     return;
64746   }
64747   {
64748     try {
64749       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64750     } catch (std::out_of_range& e) {
64751       {
64752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64753       };
64754     } catch (std::exception& e) {
64755       {
64756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64757       };
64758     } catch (Dali::DaliException e) {
64759       {
64760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64761       };
64762     } catch (...) {
64763       {
64764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64765       };
64766     }
64767   }
64768
64769 }
64770
64771
64772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64773   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64774   Dali::ResizePolicy::Type arg2 ;
64775   Dali::Dimension::Type arg3 ;
64776   SwigDirector_ViewImpl *darg = 0;
64777
64778   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64779   arg2 = (Dali::ResizePolicy::Type)jarg2;
64780   arg3 = (Dali::Dimension::Type)jarg3;
64781   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64782   if (!darg) {
64783     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64784     return;
64785   }
64786   {
64787     try {
64788       (darg)->OnSetResizePolicy(arg2,arg3);
64789     } catch (std::out_of_range& e) {
64790       {
64791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64792       };
64793     } catch (std::exception& e) {
64794       {
64795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64796       };
64797     } catch (Dali::DaliException e) {
64798       {
64799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64800       };
64801     } catch (...) {
64802       {
64803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64804       };
64805     }
64806   }
64807
64808 }
64809
64810
64811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
64812   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64813   Dali::ResizePolicy::Type arg2 ;
64814   Dali::Dimension::Type arg3 ;
64815   SwigDirector_ViewImpl *darg = 0;
64816
64817   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64818   arg2 = (Dali::ResizePolicy::Type)jarg2;
64819   arg3 = (Dali::Dimension::Type)jarg3;
64820   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64821   if (!darg) {
64822     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64823     return;
64824   }
64825   {
64826     try {
64827       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
64828     } catch (std::out_of_range& e) {
64829       {
64830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64831       };
64832     } catch (std::exception& e) {
64833       {
64834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64835       };
64836     } catch (Dali::DaliException e) {
64837       {
64838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64839       };
64840     } catch (...) {
64841       {
64842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64843       };
64844     }
64845   }
64846
64847 }
64848
64849
64850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
64851   void * jresult ;
64852   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64853   SwigDirector_ViewImpl *darg = 0;
64854   Dali::Vector3 result;
64855
64856   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64857   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64858   if (!darg) {
64859     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64860     return 0;
64861   }
64862   {
64863     try {
64864       result = (darg)->GetNaturalSize();
64865     } catch (std::out_of_range& e) {
64866       {
64867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64868       };
64869     } catch (std::exception& e) {
64870       {
64871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64872       };
64873     } catch (Dali::DaliException e) {
64874       {
64875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64876       };
64877     } catch (...) {
64878       {
64879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64880       };
64881     }
64882   }
64883
64884   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64885   return jresult;
64886 }
64887
64888
64889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
64890   void * jresult ;
64891   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64892   SwigDirector_ViewImpl *darg = 0;
64893   Dali::Vector3 result;
64894
64895   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64896   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64897   if (!darg) {
64898     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64899     return 0;
64900   }
64901   {
64902     try {
64903       result = (darg)->GetNaturalSizeSwigPublic();
64904     } catch (std::out_of_range& e) {
64905       {
64906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64907       };
64908     } catch (std::exception& e) {
64909       {
64910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64911       };
64912     } catch (Dali::DaliException e) {
64913       {
64914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64915       };
64916     } catch (...) {
64917       {
64918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64919       };
64920     }
64921   }
64922
64923   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64924   return jresult;
64925 }
64926
64927
64928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64929   float jresult ;
64930   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64931   Dali::Actor *arg2 = 0 ;
64932   Dali::Dimension::Type arg3 ;
64933   SwigDirector_ViewImpl *darg = 0;
64934   float result;
64935
64936   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64937   arg2 = (Dali::Actor *)jarg2;
64938   if (!arg2) {
64939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64940     return 0;
64941   }
64942   arg3 = (Dali::Dimension::Type)jarg3;
64943   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64944   if (!darg) {
64945     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64946     return 0;
64947   }
64948   {
64949     try {
64950       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
64951     } catch (std::out_of_range& e) {
64952       {
64953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64954       };
64955     } catch (std::exception& e) {
64956       {
64957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64958       };
64959     } catch (Dali::DaliException e) {
64960       {
64961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64962       };
64963     } catch (...) {
64964       {
64965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64966       };
64967     }
64968   }
64969
64970   jresult = result;
64971   return jresult;
64972 }
64973
64974
64975 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64976   float jresult ;
64977   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64978   Dali::Actor *arg2 = 0 ;
64979   Dali::Dimension::Type arg3 ;
64980   SwigDirector_ViewImpl *darg = 0;
64981   float result;
64982
64983   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64984   arg2 = (Dali::Actor *)jarg2;
64985   if (!arg2) {
64986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64987     return 0;
64988   }
64989   arg3 = (Dali::Dimension::Type)jarg3;
64990   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64991   if (!darg) {
64992     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64993     return 0;
64994   }
64995   {
64996     try {
64997       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
64998     } catch (std::out_of_range& e) {
64999       {
65000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65001       };
65002     } catch (std::exception& e) {
65003       {
65004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65005       };
65006     } catch (Dali::DaliException e) {
65007       {
65008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65009       };
65010     } catch (...) {
65011       {
65012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65013       };
65014     }
65015   }
65016
65017   jresult = result;
65018   return jresult;
65019 }
65020
65021
65022 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
65023   float jresult ;
65024   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65025   float arg2 ;
65026   SwigDirector_ViewImpl *darg = 0;
65027   float result;
65028
65029   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65030   arg2 = (float)jarg2;
65031   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65032   if (!darg) {
65033     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65034     return 0;
65035   }
65036   {
65037     try {
65038       result = (float)(darg)->GetHeightForWidth(arg2);
65039     } catch (std::out_of_range& e) {
65040       {
65041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65042       };
65043     } catch (std::exception& e) {
65044       {
65045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65046       };
65047     } catch (Dali::DaliException e) {
65048       {
65049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65050       };
65051     } catch (...) {
65052       {
65053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65054       };
65055     }
65056   }
65057
65058   jresult = result;
65059   return jresult;
65060 }
65061
65062
65063 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65064   float jresult ;
65065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65066   float arg2 ;
65067   SwigDirector_ViewImpl *darg = 0;
65068   float result;
65069
65070   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65071   arg2 = (float)jarg2;
65072   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65073   if (!darg) {
65074     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65075     return 0;
65076   }
65077   {
65078     try {
65079       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65080     } catch (std::out_of_range& e) {
65081       {
65082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65083       };
65084     } catch (std::exception& e) {
65085       {
65086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65087       };
65088     } catch (Dali::DaliException e) {
65089       {
65090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65091       };
65092     } catch (...) {
65093       {
65094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65095       };
65096     }
65097   }
65098
65099   jresult = result;
65100   return jresult;
65101 }
65102
65103
65104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65105   float jresult ;
65106   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65107   float arg2 ;
65108   SwigDirector_ViewImpl *darg = 0;
65109   float result;
65110
65111   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65112   arg2 = (float)jarg2;
65113   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65114   if (!darg) {
65115     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65116     return 0;
65117   }
65118   {
65119     try {
65120       result = (float)(darg)->GetWidthForHeight(arg2);
65121     } catch (std::out_of_range& e) {
65122       {
65123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65124       };
65125     } catch (std::exception& e) {
65126       {
65127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65128       };
65129     } catch (Dali::DaliException e) {
65130       {
65131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65132       };
65133     } catch (...) {
65134       {
65135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65136       };
65137     }
65138   }
65139
65140   jresult = result;
65141   return jresult;
65142 }
65143
65144
65145 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65146   float jresult ;
65147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65148   float arg2 ;
65149   SwigDirector_ViewImpl *darg = 0;
65150   float result;
65151
65152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65153   arg2 = (float)jarg2;
65154   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65155   if (!darg) {
65156     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65157     return 0;
65158   }
65159   {
65160     try {
65161       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65162     } catch (std::out_of_range& e) {
65163       {
65164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65165       };
65166     } catch (std::exception& e) {
65167       {
65168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65169       };
65170     } catch (Dali::DaliException e) {
65171       {
65172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65173       };
65174     } catch (...) {
65175       {
65176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65177       };
65178     }
65179   }
65180
65181   jresult = result;
65182   return jresult;
65183 }
65184
65185
65186 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65187   unsigned int jresult ;
65188   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65189   Dali::Dimension::Type arg2 ;
65190   SwigDirector_ViewImpl *darg = 0;
65191   bool result;
65192
65193   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65194   arg2 = (Dali::Dimension::Type)jarg2;
65195   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65196   if (!darg) {
65197     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65198     return 0;
65199   }
65200   {
65201     try {
65202       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65203     } catch (std::out_of_range& e) {
65204       {
65205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65206       };
65207     } catch (std::exception& e) {
65208       {
65209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65210       };
65211     } catch (Dali::DaliException e) {
65212       {
65213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65214       };
65215     } catch (...) {
65216       {
65217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65218       };
65219     }
65220   }
65221
65222   jresult = result;
65223   return jresult;
65224 }
65225
65226
65227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65228   unsigned int jresult ;
65229   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65230   Dali::Dimension::Type arg2 ;
65231   SwigDirector_ViewImpl *darg = 0;
65232   bool result;
65233
65234   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65235   arg2 = (Dali::Dimension::Type)jarg2;
65236   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65237   if (!darg) {
65238     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65239     return 0;
65240   }
65241   {
65242     try {
65243       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65244     } catch (std::out_of_range& e) {
65245       {
65246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65247       };
65248     } catch (std::exception& e) {
65249       {
65250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65251       };
65252     } catch (Dali::DaliException e) {
65253       {
65254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65255       };
65256     } catch (...) {
65257       {
65258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65259       };
65260     }
65261   }
65262
65263   jresult = result;
65264   return jresult;
65265 }
65266
65267
65268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65269   unsigned int jresult ;
65270   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65271   SwigDirector_ViewImpl *darg = 0;
65272   bool result;
65273
65274   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65275   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65276   if (!darg) {
65277     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65278     return 0;
65279   }
65280   {
65281     try {
65282       result = (bool)(darg)->RelayoutDependentOnChildren();
65283     } catch (std::out_of_range& e) {
65284       {
65285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65286       };
65287     } catch (std::exception& e) {
65288       {
65289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65290       };
65291     } catch (Dali::DaliException e) {
65292       {
65293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65294       };
65295     } catch (...) {
65296       {
65297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65298       };
65299     }
65300   }
65301
65302   jresult = result;
65303   return jresult;
65304 }
65305
65306
65307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
65308   unsigned int jresult ;
65309   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65310   SwigDirector_ViewImpl *darg = 0;
65311   bool result;
65312
65313   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65314   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65315   if (!darg) {
65316     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65317     return 0;
65318   }
65319   {
65320     try {
65321       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
65322     } catch (std::out_of_range& e) {
65323       {
65324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65325       };
65326     } catch (std::exception& e) {
65327       {
65328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65329       };
65330     } catch (Dali::DaliException e) {
65331       {
65332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65333       };
65334     } catch (...) {
65335       {
65336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65337       };
65338     }
65339   }
65340
65341   jresult = result;
65342   return jresult;
65343 }
65344
65345
65346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65347   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65348   Dali::Dimension::Type arg2 ;
65349   SwigDirector_ViewImpl *darg = 0;
65350
65351   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65352   arg2 = (Dali::Dimension::Type)jarg2;
65353   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65354   if (!darg) {
65355     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65356     return;
65357   }
65358   {
65359     try {
65360       (darg)->OnCalculateRelayoutSize(arg2);
65361     } catch (std::out_of_range& e) {
65362       {
65363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65364       };
65365     } catch (std::exception& e) {
65366       {
65367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65368       };
65369     } catch (Dali::DaliException e) {
65370       {
65371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65372       };
65373     } catch (...) {
65374       {
65375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65376       };
65377     }
65378   }
65379
65380 }
65381
65382
65383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65384   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65385   Dali::Dimension::Type arg2 ;
65386   SwigDirector_ViewImpl *darg = 0;
65387
65388   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65389   arg2 = (Dali::Dimension::Type)jarg2;
65390   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65391   if (!darg) {
65392     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65393     return;
65394   }
65395   {
65396     try {
65397       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65398     } catch (std::out_of_range& e) {
65399       {
65400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65401       };
65402     } catch (std::exception& e) {
65403       {
65404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65405       };
65406     } catch (Dali::DaliException e) {
65407       {
65408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65409       };
65410     } catch (...) {
65411       {
65412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65413       };
65414     }
65415   }
65416
65417 }
65418
65419
65420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65421   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65422   float arg2 ;
65423   Dali::Dimension::Type arg3 ;
65424   SwigDirector_ViewImpl *darg = 0;
65425
65426   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65427   arg2 = (float)jarg2;
65428   arg3 = (Dali::Dimension::Type)jarg3;
65429   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65430   if (!darg) {
65431     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65432     return;
65433   }
65434   {
65435     try {
65436       (darg)->OnLayoutNegotiated(arg2,arg3);
65437     } catch (std::out_of_range& e) {
65438       {
65439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65440       };
65441     } catch (std::exception& e) {
65442       {
65443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65444       };
65445     } catch (Dali::DaliException e) {
65446       {
65447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65448       };
65449     } catch (...) {
65450       {
65451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65452       };
65453     }
65454   }
65455
65456 }
65457
65458
65459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
65460   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65461   float arg2 ;
65462   Dali::Dimension::Type arg3 ;
65463   SwigDirector_ViewImpl *darg = 0;
65464
65465   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65466   arg2 = (float)jarg2;
65467   arg3 = (Dali::Dimension::Type)jarg3;
65468   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65469   if (!darg) {
65470     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65471     return;
65472   }
65473   {
65474     try {
65475       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
65476     } catch (std::out_of_range& e) {
65477       {
65478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65479       };
65480     } catch (std::exception& e) {
65481       {
65482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65483       };
65484     } catch (Dali::DaliException e) {
65485       {
65486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65487       };
65488     } catch (...) {
65489       {
65490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65491       };
65492     }
65493   }
65494
65495 }
65496
65497
65498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
65499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65500
65501   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65502   {
65503     try {
65504       (arg1)->OnInitialize();
65505     } catch (std::out_of_range& e) {
65506       {
65507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65508       };
65509     } catch (std::exception& e) {
65510       {
65511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65512       };
65513     } catch (Dali::DaliException e) {
65514       {
65515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65516       };
65517     } catch (...) {
65518       {
65519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65520       };
65521     }
65522   }
65523
65524 }
65525
65526
65527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65528   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65529
65530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65531   {
65532     try {
65533       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65534     } catch (std::out_of_range& e) {
65535       {
65536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65537       };
65538     } catch (std::exception& e) {
65539       {
65540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65541       };
65542     } catch (Dali::DaliException e) {
65543       {
65544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65545       };
65546     } catch (...) {
65547       {
65548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65549       };
65550     }
65551   }
65552
65553 }
65554
65555
65556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65557   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65558   Dali::Actor *arg2 = 0 ;
65559
65560   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65561   arg2 = (Dali::Actor *)jarg2;
65562   if (!arg2) {
65563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65564     return ;
65565   }
65566   {
65567     try {
65568       (arg1)->OnControlChildAdd(*arg2);
65569     } catch (std::out_of_range& e) {
65570       {
65571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65572       };
65573     } catch (std::exception& e) {
65574       {
65575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65576       };
65577     } catch (Dali::DaliException e) {
65578       {
65579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65580       };
65581     } catch (...) {
65582       {
65583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65584       };
65585     }
65586   }
65587
65588 }
65589
65590
65591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65593   Dali::Actor *arg2 = 0 ;
65594
65595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65596   arg2 = (Dali::Actor *)jarg2;
65597   if (!arg2) {
65598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65599     return ;
65600   }
65601   {
65602     try {
65603       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65604     } catch (std::out_of_range& e) {
65605       {
65606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65607       };
65608     } catch (std::exception& e) {
65609       {
65610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65611       };
65612     } catch (Dali::DaliException e) {
65613       {
65614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65615       };
65616     } catch (...) {
65617       {
65618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65619       };
65620     }
65621   }
65622
65623 }
65624
65625
65626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65627   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65628   Dali::Actor *arg2 = 0 ;
65629
65630   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65631   arg2 = (Dali::Actor *)jarg2;
65632   if (!arg2) {
65633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65634     return ;
65635   }
65636   {
65637     try {
65638       (arg1)->OnControlChildRemove(*arg2);
65639     } catch (std::out_of_range& e) {
65640       {
65641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65642       };
65643     } catch (std::exception& e) {
65644       {
65645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65646       };
65647     } catch (Dali::DaliException e) {
65648       {
65649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65650       };
65651     } catch (...) {
65652       {
65653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65654       };
65655     }
65656   }
65657
65658 }
65659
65660
65661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65662   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65663   Dali::Actor *arg2 = 0 ;
65664
65665   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65666   arg2 = (Dali::Actor *)jarg2;
65667   if (!arg2) {
65668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65669     return ;
65670   }
65671   {
65672     try {
65673       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65674     } catch (std::out_of_range& e) {
65675       {
65676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65677       };
65678     } catch (std::exception& e) {
65679       {
65680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65681       };
65682     } catch (Dali::DaliException e) {
65683       {
65684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65685       };
65686     } catch (...) {
65687       {
65688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65689       };
65690     }
65691   }
65692
65693 }
65694
65695
65696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65697   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65698   Dali::Toolkit::StyleManager arg2 ;
65699   Dali::StyleChange::Type arg3 ;
65700   Dali::Toolkit::StyleManager *argp2 ;
65701
65702   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65703   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65704   if (!argp2) {
65705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65706     return ;
65707   }
65708   arg2 = *argp2;
65709   arg3 = (Dali::StyleChange::Type)jarg3;
65710   {
65711     try {
65712       (arg1)->OnStyleChange(arg2,arg3);
65713     } catch (std::out_of_range& e) {
65714       {
65715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65716       };
65717     } catch (std::exception& e) {
65718       {
65719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65720       };
65721     } catch (Dali::DaliException e) {
65722       {
65723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65724       };
65725     } catch (...) {
65726       {
65727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65728       };
65729     }
65730   }
65731
65732 }
65733
65734
65735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
65736   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65737   Dali::Toolkit::StyleManager arg2 ;
65738   Dali::StyleChange::Type arg3 ;
65739   Dali::Toolkit::StyleManager *argp2 ;
65740
65741   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65742   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65743   if (!argp2) {
65744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65745     return ;
65746   }
65747   arg2 = *argp2;
65748   arg3 = (Dali::StyleChange::Type)jarg3;
65749   {
65750     try {
65751       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
65752     } catch (std::out_of_range& e) {
65753       {
65754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65755       };
65756     } catch (std::exception& e) {
65757       {
65758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65759       };
65760     } catch (Dali::DaliException e) {
65761       {
65762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65763       };
65764     } catch (...) {
65765       {
65766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65767       };
65768     }
65769   }
65770
65771 }
65772
65773
65774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65775   unsigned int jresult ;
65776   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65777   bool result;
65778
65779   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65780   {
65781     try {
65782       result = (bool)(arg1)->OnAccessibilityActivated();
65783     } catch (std::out_of_range& e) {
65784       {
65785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65786       };
65787     } catch (std::exception& e) {
65788       {
65789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65790       };
65791     } catch (Dali::DaliException e) {
65792       {
65793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65794       };
65795     } catch (...) {
65796       {
65797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65798       };
65799     }
65800   }
65801
65802   jresult = result;
65803   return jresult;
65804 }
65805
65806
65807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65808   unsigned int jresult ;
65809   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65810   bool result;
65811
65812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65813   {
65814     try {
65815       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65816     } catch (std::out_of_range& e) {
65817       {
65818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65819       };
65820     } catch (std::exception& e) {
65821       {
65822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65823       };
65824     } catch (Dali::DaliException e) {
65825       {
65826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65827       };
65828     } catch (...) {
65829       {
65830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65831       };
65832     }
65833   }
65834
65835   jresult = result;
65836   return jresult;
65837 }
65838
65839
65840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65841   unsigned int jresult ;
65842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65843   Dali::PanGesture arg2 ;
65844   Dali::PanGesture *argp2 ;
65845   bool result;
65846
65847   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65848   argp2 = (Dali::PanGesture *)jarg2;
65849   if (!argp2) {
65850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65851     return 0;
65852   }
65853   arg2 = *argp2;
65854   {
65855     try {
65856       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65857     } catch (std::out_of_range& e) {
65858       {
65859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65860       };
65861     } catch (std::exception& e) {
65862       {
65863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65864       };
65865     } catch (Dali::DaliException e) {
65866       {
65867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65868       };
65869     } catch (...) {
65870       {
65871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65872       };
65873     }
65874   }
65875
65876   jresult = result;
65877   return jresult;
65878 }
65879
65880
65881 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65882   unsigned int jresult ;
65883   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65884   Dali::PanGesture arg2 ;
65885   Dali::PanGesture *argp2 ;
65886   bool result;
65887
65888   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65889   argp2 = (Dali::PanGesture *)jarg2;
65890   if (!argp2) {
65891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65892     return 0;
65893   }
65894   arg2 = *argp2;
65895   {
65896     try {
65897       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65898     } catch (std::out_of_range& e) {
65899       {
65900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65901       };
65902     } catch (std::exception& e) {
65903       {
65904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65905       };
65906     } catch (Dali::DaliException e) {
65907       {
65908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65909       };
65910     } catch (...) {
65911       {
65912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65913       };
65914     }
65915   }
65916
65917   jresult = result;
65918   return jresult;
65919 }
65920
65921
65922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65923   unsigned int jresult ;
65924   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65925   Dali::TouchEvent *arg2 = 0 ;
65926   bool result;
65927
65928   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65929   arg2 = (Dali::TouchEvent *)jarg2;
65930   if (!arg2) {
65931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65932     return 0;
65933   }
65934   {
65935     try {
65936       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65937     } catch (std::out_of_range& e) {
65938       {
65939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65940       };
65941     } catch (std::exception& e) {
65942       {
65943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65944       };
65945     } catch (Dali::DaliException e) {
65946       {
65947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65948       };
65949     } catch (...) {
65950       {
65951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65952       };
65953     }
65954   }
65955
65956   jresult = result;
65957   return jresult;
65958 }
65959
65960
65961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65962   unsigned int jresult ;
65963   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65964   Dali::TouchEvent *arg2 = 0 ;
65965   bool result;
65966
65967   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65968   arg2 = (Dali::TouchEvent *)jarg2;
65969   if (!arg2) {
65970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65971     return 0;
65972   }
65973   {
65974     try {
65975       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
65976     } catch (std::out_of_range& e) {
65977       {
65978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65979       };
65980     } catch (std::exception& e) {
65981       {
65982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65983       };
65984     } catch (Dali::DaliException e) {
65985       {
65986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65987       };
65988     } catch (...) {
65989       {
65990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65991       };
65992     }
65993   }
65994
65995   jresult = result;
65996   return jresult;
65997 }
65998
65999
66000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
66001   unsigned int jresult ;
66002   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66003   bool arg2 ;
66004   bool result;
66005
66006   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66007   arg2 = jarg2 ? true : false;
66008   {
66009     try {
66010       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
66011     } catch (std::out_of_range& e) {
66012       {
66013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66014       };
66015     } catch (std::exception& e) {
66016       {
66017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66018       };
66019     } catch (Dali::DaliException e) {
66020       {
66021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66022       };
66023     } catch (...) {
66024       {
66025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66026       };
66027     }
66028   }
66029
66030   jresult = result;
66031   return jresult;
66032 }
66033
66034
66035 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
66036   unsigned int jresult ;
66037   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66038   bool arg2 ;
66039   bool result;
66040
66041   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66042   arg2 = jarg2 ? true : false;
66043   {
66044     try {
66045       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66046     } catch (std::out_of_range& e) {
66047       {
66048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66049       };
66050     } catch (std::exception& e) {
66051       {
66052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66053       };
66054     } catch (Dali::DaliException e) {
66055       {
66056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66057       };
66058     } catch (...) {
66059       {
66060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66061       };
66062     }
66063   }
66064
66065   jresult = result;
66066   return jresult;
66067 }
66068
66069
66070 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66071   unsigned int jresult ;
66072   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66073   bool result;
66074
66075   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66076   {
66077     try {
66078       result = (bool)(arg1)->OnAccessibilityZoom();
66079     } catch (std::out_of_range& e) {
66080       {
66081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66082       };
66083     } catch (std::exception& e) {
66084       {
66085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66086       };
66087     } catch (Dali::DaliException e) {
66088       {
66089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66090       };
66091     } catch (...) {
66092       {
66093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66094       };
66095     }
66096   }
66097
66098   jresult = result;
66099   return jresult;
66100 }
66101
66102
66103 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66104   unsigned int jresult ;
66105   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66106   bool result;
66107
66108   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66109   {
66110     try {
66111       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66112     } catch (std::out_of_range& e) {
66113       {
66114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66115       };
66116     } catch (std::exception& e) {
66117       {
66118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66119       };
66120     } catch (Dali::DaliException e) {
66121       {
66122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66123       };
66124     } catch (...) {
66125       {
66126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66127       };
66128     }
66129   }
66130
66131   jresult = result;
66132   return jresult;
66133 }
66134
66135
66136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66137   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66138
66139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66140   {
66141     try {
66142       (arg1)->OnKeyInputFocusGained();
66143     } catch (std::out_of_range& e) {
66144       {
66145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66146       };
66147     } catch (std::exception& e) {
66148       {
66149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66150       };
66151     } catch (Dali::DaliException e) {
66152       {
66153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66154       };
66155     } catch (...) {
66156       {
66157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66158       };
66159     }
66160   }
66161
66162 }
66163
66164
66165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66166   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66167
66168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66169   {
66170     try {
66171       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66172     } catch (std::out_of_range& e) {
66173       {
66174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66175       };
66176     } catch (std::exception& e) {
66177       {
66178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66179       };
66180     } catch (Dali::DaliException e) {
66181       {
66182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66183       };
66184     } catch (...) {
66185       {
66186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66187       };
66188     }
66189   }
66190
66191 }
66192
66193
66194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66195   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66196
66197   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66198   {
66199     try {
66200       (arg1)->OnKeyInputFocusLost();
66201     } catch (std::out_of_range& e) {
66202       {
66203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66204       };
66205     } catch (std::exception& e) {
66206       {
66207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66208       };
66209     } catch (Dali::DaliException e) {
66210       {
66211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66212       };
66213     } catch (...) {
66214       {
66215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66216       };
66217     }
66218   }
66219
66220 }
66221
66222
66223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66224   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66225
66226   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66227   {
66228     try {
66229       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66230     } catch (std::out_of_range& e) {
66231       {
66232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66233       };
66234     } catch (std::exception& e) {
66235       {
66236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66237       };
66238     } catch (Dali::DaliException e) {
66239       {
66240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66241       };
66242     } catch (...) {
66243       {
66244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66245       };
66246     }
66247   }
66248
66249 }
66250
66251
66252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66253   void * jresult ;
66254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66255   Dali::Actor arg2 ;
66256   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66257   bool arg4 ;
66258   Dali::Actor *argp2 ;
66259   Dali::Actor result;
66260
66261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66262   argp2 = (Dali::Actor *)jarg2;
66263   if (!argp2) {
66264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66265     return 0;
66266   }
66267   arg2 = *argp2;
66268   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66269   arg4 = jarg4 ? true : false;
66270   {
66271     try {
66272       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66273     } catch (std::out_of_range& e) {
66274       {
66275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66276       };
66277     } catch (std::exception& e) {
66278       {
66279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66280       };
66281     } catch (Dali::DaliException e) {
66282       {
66283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66284       };
66285     } catch (...) {
66286       {
66287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66288       };
66289     }
66290   }
66291
66292   jresult = new Dali::Actor((const Dali::Actor &)result);
66293   return jresult;
66294 }
66295
66296
66297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66298   void * jresult ;
66299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66300   Dali::Actor arg2 ;
66301   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66302   bool arg4 ;
66303   Dali::Actor *argp2 ;
66304   Dali::Actor result;
66305
66306   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66307   argp2 = (Dali::Actor *)jarg2;
66308   if (!argp2) {
66309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66310     return 0;
66311   }
66312   arg2 = *argp2;
66313   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66314   arg4 = jarg4 ? true : false;
66315   {
66316     try {
66317       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66318     } catch (std::out_of_range& e) {
66319       {
66320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66321       };
66322     } catch (std::exception& e) {
66323       {
66324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66325       };
66326     } catch (Dali::DaliException e) {
66327       {
66328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66329       };
66330     } catch (...) {
66331       {
66332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66333       };
66334     }
66335   }
66336
66337   jresult = new Dali::Actor((const Dali::Actor &)result);
66338   return jresult;
66339 }
66340
66341
66342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66343   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66344   Dali::Actor arg2 ;
66345   Dali::Actor *argp2 ;
66346
66347   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66348   argp2 = (Dali::Actor *)jarg2;
66349   if (!argp2) {
66350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66351     return ;
66352   }
66353   arg2 = *argp2;
66354   {
66355     try {
66356       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66357     } catch (std::out_of_range& e) {
66358       {
66359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66360       };
66361     } catch (std::exception& e) {
66362       {
66363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66364       };
66365     } catch (Dali::DaliException e) {
66366       {
66367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66368       };
66369     } catch (...) {
66370       {
66371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66372       };
66373     }
66374   }
66375
66376 }
66377
66378
66379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66381   Dali::Actor arg2 ;
66382   Dali::Actor *argp2 ;
66383
66384   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66385   argp2 = (Dali::Actor *)jarg2;
66386   if (!argp2) {
66387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66388     return ;
66389   }
66390   arg2 = *argp2;
66391   {
66392     try {
66393       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66394     } catch (std::out_of_range& e) {
66395       {
66396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66397       };
66398     } catch (std::exception& e) {
66399       {
66400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66401       };
66402     } catch (Dali::DaliException e) {
66403       {
66404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66405       };
66406     } catch (...) {
66407       {
66408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66409       };
66410     }
66411   }
66412
66413 }
66414
66415
66416 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66417   unsigned int jresult ;
66418   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66419   bool result;
66420
66421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66422   {
66423     try {
66424       result = (bool)(arg1)->OnKeyboardEnter();
66425     } catch (std::out_of_range& e) {
66426       {
66427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66428       };
66429     } catch (std::exception& e) {
66430       {
66431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66432       };
66433     } catch (Dali::DaliException e) {
66434       {
66435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66436       };
66437     } catch (...) {
66438       {
66439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66440       };
66441     }
66442   }
66443
66444   jresult = result;
66445   return jresult;
66446 }
66447
66448
66449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66450   unsigned int jresult ;
66451   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66452   bool result;
66453
66454   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66455   {
66456     try {
66457       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66458     } catch (std::out_of_range& e) {
66459       {
66460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66461       };
66462     } catch (std::exception& e) {
66463       {
66464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66465       };
66466     } catch (Dali::DaliException e) {
66467       {
66468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66469       };
66470     } catch (...) {
66471       {
66472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66473       };
66474     }
66475   }
66476
66477   jresult = result;
66478   return jresult;
66479 }
66480
66481
66482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66483   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66484   Dali::PinchGesture *arg2 = 0 ;
66485
66486   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66487   arg2 = (Dali::PinchGesture *)jarg2;
66488   if (!arg2) {
66489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66490     return ;
66491   }
66492   {
66493     try {
66494       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66495     } catch (std::out_of_range& e) {
66496       {
66497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66498       };
66499     } catch (std::exception& e) {
66500       {
66501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66502       };
66503     } catch (Dali::DaliException e) {
66504       {
66505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66506       };
66507     } catch (...) {
66508       {
66509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66510       };
66511     }
66512   }
66513
66514 }
66515
66516
66517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66519   Dali::PinchGesture *arg2 = 0 ;
66520
66521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66522   arg2 = (Dali::PinchGesture *)jarg2;
66523   if (!arg2) {
66524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66525     return ;
66526   }
66527   {
66528     try {
66529       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66530     } catch (std::out_of_range& e) {
66531       {
66532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66533       };
66534     } catch (std::exception& e) {
66535       {
66536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66537       };
66538     } catch (Dali::DaliException e) {
66539       {
66540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66541       };
66542     } catch (...) {
66543       {
66544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66545       };
66546     }
66547   }
66548
66549 }
66550
66551
66552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66554   Dali::PanGesture *arg2 = 0 ;
66555
66556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66557   arg2 = (Dali::PanGesture *)jarg2;
66558   if (!arg2) {
66559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66560     return ;
66561   }
66562   {
66563     try {
66564       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66565     } catch (std::out_of_range& e) {
66566       {
66567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66568       };
66569     } catch (std::exception& e) {
66570       {
66571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66572       };
66573     } catch (Dali::DaliException e) {
66574       {
66575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66576       };
66577     } catch (...) {
66578       {
66579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66580       };
66581     }
66582   }
66583
66584 }
66585
66586
66587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66589   Dali::PanGesture *arg2 = 0 ;
66590
66591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66592   arg2 = (Dali::PanGesture *)jarg2;
66593   if (!arg2) {
66594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66595     return ;
66596   }
66597   {
66598     try {
66599       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66600     } catch (std::out_of_range& e) {
66601       {
66602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66603       };
66604     } catch (std::exception& e) {
66605       {
66606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66607       };
66608     } catch (Dali::DaliException e) {
66609       {
66610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66611       };
66612     } catch (...) {
66613       {
66614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66615       };
66616     }
66617   }
66618
66619 }
66620
66621
66622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66623   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66624   Dali::TapGesture *arg2 = 0 ;
66625
66626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66627   arg2 = (Dali::TapGesture *)jarg2;
66628   if (!arg2) {
66629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66630     return ;
66631   }
66632   {
66633     try {
66634       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66635     } catch (std::out_of_range& e) {
66636       {
66637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66638       };
66639     } catch (std::exception& e) {
66640       {
66641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66642       };
66643     } catch (Dali::DaliException e) {
66644       {
66645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66646       };
66647     } catch (...) {
66648       {
66649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66650       };
66651     }
66652   }
66653
66654 }
66655
66656
66657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66658   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66659   Dali::TapGesture *arg2 = 0 ;
66660
66661   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66662   arg2 = (Dali::TapGesture *)jarg2;
66663   if (!arg2) {
66664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66665     return ;
66666   }
66667   {
66668     try {
66669       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66670     } catch (std::out_of_range& e) {
66671       {
66672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66673       };
66674     } catch (std::exception& e) {
66675       {
66676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66677       };
66678     } catch (Dali::DaliException e) {
66679       {
66680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66681       };
66682     } catch (...) {
66683       {
66684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66685       };
66686     }
66687   }
66688
66689 }
66690
66691
66692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66693   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66694   Dali::LongPressGesture *arg2 = 0 ;
66695
66696   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66697   arg2 = (Dali::LongPressGesture *)jarg2;
66698   if (!arg2) {
66699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66700     return ;
66701   }
66702   {
66703     try {
66704       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66705     } catch (std::out_of_range& e) {
66706       {
66707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66708       };
66709     } catch (std::exception& e) {
66710       {
66711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66712       };
66713     } catch (Dali::DaliException e) {
66714       {
66715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66716       };
66717     } catch (...) {
66718       {
66719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66720       };
66721     }
66722   }
66723
66724 }
66725
66726
66727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66728   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66729   Dali::LongPressGesture *arg2 = 0 ;
66730
66731   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66732   arg2 = (Dali::LongPressGesture *)jarg2;
66733   if (!arg2) {
66734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66735     return ;
66736   }
66737   {
66738     try {
66739       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66740     } catch (std::out_of_range& e) {
66741       {
66742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66743       };
66744     } catch (std::exception& e) {
66745       {
66746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66747       };
66748     } catch (Dali::DaliException e) {
66749       {
66750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66751       };
66752     } catch (...) {
66753       {
66754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66755       };
66756     }
66757   }
66758
66759 }
66760
66761
66762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66763   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66764   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66765   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66766
66767   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66768   arg2 = (Dali::SlotObserver *)jarg2;
66769   arg3 = (Dali::CallbackBase *)jarg3;
66770   {
66771     try {
66772       (arg1)->SignalConnected(arg2,arg3);
66773     } catch (std::out_of_range& e) {
66774       {
66775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66776       };
66777     } catch (std::exception& e) {
66778       {
66779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66780       };
66781     } catch (Dali::DaliException e) {
66782       {
66783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66784       };
66785     } catch (...) {
66786       {
66787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66788       };
66789     }
66790   }
66791
66792 }
66793
66794
66795 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66796   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66797   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66798   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66799
66800   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66801   arg2 = (Dali::SlotObserver *)jarg2;
66802   arg3 = (Dali::CallbackBase *)jarg3;
66803   {
66804     try {
66805       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66806     } catch (std::out_of_range& e) {
66807       {
66808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66809       };
66810     } catch (std::exception& e) {
66811       {
66812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66813       };
66814     } catch (Dali::DaliException e) {
66815       {
66816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66817       };
66818     } catch (...) {
66819       {
66820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66821       };
66822     }
66823   }
66824
66825 }
66826
66827
66828 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66829   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66830   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66831   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66832
66833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66834   arg2 = (Dali::SlotObserver *)jarg2;
66835   arg3 = (Dali::CallbackBase *)jarg3;
66836   {
66837     try {
66838       (arg1)->SignalDisconnected(arg2,arg3);
66839     } catch (std::out_of_range& e) {
66840       {
66841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66842       };
66843     } catch (std::exception& e) {
66844       {
66845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66846       };
66847     } catch (Dali::DaliException e) {
66848       {
66849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66850       };
66851     } catch (...) {
66852       {
66853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66854       };
66855     }
66856   }
66857
66858 }
66859
66860
66861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66862   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66863   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66864   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66865
66866   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66867   arg2 = (Dali::SlotObserver *)jarg2;
66868   arg3 = (Dali::CallbackBase *)jarg3;
66869   {
66870     try {
66871       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
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_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) {
66895   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66896   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66897   if (director) {
66898     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);
66899   }
66900 }
66901
66902
66903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66904   void * jresult ;
66905   Dali::Toolkit::Control *arg1 = 0 ;
66906   Dali::Toolkit::Internal::Control *result = 0 ;
66907
66908   arg1 = (Dali::Toolkit::Control *)jarg1;
66909   if (!arg1) {
66910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66911     return 0;
66912   }
66913   {
66914     try {
66915       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66916     } catch (std::out_of_range& e) {
66917       {
66918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66919       };
66920     } catch (std::exception& e) {
66921       {
66922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66923       };
66924     } catch (Dali::DaliException e) {
66925       {
66926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66927       };
66928     } catch (...) {
66929       {
66930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66931       };
66932     }
66933   }
66934
66935   jresult = (void *)result;
66936   return jresult;
66937 }
66938
66939
66940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66941   int jresult ;
66942   int result;
66943
66944   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66945   jresult = (int)result;
66946   return jresult;
66947 }
66948
66949
66950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
66951   int jresult ;
66952   int result;
66953
66954   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
66955   jresult = (int)result;
66956   return jresult;
66957 }
66958
66959
66960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
66961   int jresult ;
66962   int result;
66963
66964   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
66965   jresult = (int)result;
66966   return jresult;
66967 }
66968
66969
66970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
66971   int jresult ;
66972   int result;
66973
66974   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
66975   jresult = (int)result;
66976   return jresult;
66977 }
66978
66979
66980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
66981   int jresult ;
66982   int result;
66983
66984   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
66985   jresult = (int)result;
66986   return jresult;
66987 }
66988
66989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
66990   int jresult ;
66991   int result;
66992
66993   result = (int)Dali::Toolkit::Control::Property::MARGIN;
66994   jresult = (int)result;
66995   return jresult;
66996 }
66997
66998
66999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
67000   int jresult ;
67001   int result;
67002
67003   result = (int)Dali::Toolkit::Control::Property::PADDING;
67004   jresult = (int)result;
67005   return jresult;
67006 }
67007
67008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
67009   void * jresult ;
67010   Dali::Toolkit::Control::Property *result = 0 ;
67011
67012   {
67013     try {
67014       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
67015     } catch (std::out_of_range& e) {
67016       {
67017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67018       };
67019     } catch (std::exception& e) {
67020       {
67021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67022       };
67023     } catch (Dali::DaliException e) {
67024       {
67025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67026       };
67027     } catch (...) {
67028       {
67029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67030       };
67031     }
67032   }
67033
67034   jresult = (void *)result;
67035   return jresult;
67036 }
67037
67038
67039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67040   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67041
67042   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67043   {
67044     try {
67045       delete arg1;
67046     } catch (std::out_of_range& e) {
67047       {
67048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67049       };
67050     } catch (std::exception& e) {
67051       {
67052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67053       };
67054     } catch (Dali::DaliException e) {
67055       {
67056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67057       };
67058     } catch (...) {
67059       {
67060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67061       };
67062     }
67063   }
67064
67065 }
67066
67067
67068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67069   void * jresult ;
67070   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67071
67072   {
67073     try {
67074       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67075     } catch (std::out_of_range& e) {
67076       {
67077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67078       };
67079     } catch (std::exception& e) {
67080       {
67081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67082       };
67083     } catch (Dali::DaliException e) {
67084       {
67085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67086       };
67087     } catch (...) {
67088       {
67089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67090       };
67091     }
67092   }
67093
67094   jresult = (void *)result;
67095   return jresult;
67096 }
67097
67098
67099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67100   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67101
67102   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67103   {
67104     try {
67105       delete arg1;
67106     } catch (std::out_of_range& e) {
67107       {
67108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67109       };
67110     } catch (std::exception& e) {
67111       {
67112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67113       };
67114     } catch (Dali::DaliException e) {
67115       {
67116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67117       };
67118     } catch (...) {
67119       {
67120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67121       };
67122     }
67123   }
67124
67125 }
67126
67127
67128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67129   void * jresult ;
67130   Dali::Toolkit::Control result;
67131
67132   {
67133     try {
67134       result = Dali::Toolkit::Control::New();
67135     } catch (std::out_of_range& e) {
67136       {
67137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67138       };
67139     } catch (std::exception& e) {
67140       {
67141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67142       };
67143     } catch (Dali::DaliException e) {
67144       {
67145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67146       };
67147     } catch (...) {
67148       {
67149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67150       };
67151     }
67152   }
67153
67154   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67155   return jresult;
67156 }
67157
67158
67159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67160   void * jresult ;
67161   Dali::Toolkit::Control *result = 0 ;
67162
67163   {
67164     try {
67165       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67166     } catch (std::out_of_range& e) {
67167       {
67168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67169       };
67170     } catch (std::exception& e) {
67171       {
67172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67173       };
67174     } catch (Dali::DaliException e) {
67175       {
67176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67177       };
67178     } catch (...) {
67179       {
67180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67181       };
67182     }
67183   }
67184
67185   jresult = (void *)result;
67186   return jresult;
67187 }
67188
67189
67190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67191   void * jresult ;
67192   Dali::Toolkit::Control *arg1 = 0 ;
67193   Dali::Toolkit::Control *result = 0 ;
67194
67195   arg1 = (Dali::Toolkit::Control *)jarg1;
67196   if (!arg1) {
67197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67198     return 0;
67199   }
67200   {
67201     try {
67202       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67203     } catch (std::out_of_range& e) {
67204       {
67205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67206       };
67207     } catch (std::exception& e) {
67208       {
67209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67210       };
67211     } catch (Dali::DaliException e) {
67212       {
67213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67214       };
67215     } catch (...) {
67216       {
67217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67218       };
67219     }
67220   }
67221
67222   jresult = (void *)result;
67223   return jresult;
67224 }
67225
67226
67227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67228   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67229
67230   arg1 = (Dali::Toolkit::Control *)jarg1;
67231   {
67232     try {
67233       delete arg1;
67234     } catch (std::out_of_range& e) {
67235       {
67236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67237       };
67238     } catch (std::exception& e) {
67239       {
67240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67241       };
67242     } catch (Dali::DaliException e) {
67243       {
67244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67245       };
67246     } catch (...) {
67247       {
67248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67249       };
67250     }
67251   }
67252
67253 }
67254
67255
67256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67257   void * jresult ;
67258   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67259   Dali::Toolkit::Control *arg2 = 0 ;
67260   Dali::Toolkit::Control *result = 0 ;
67261
67262   arg1 = (Dali::Toolkit::Control *)jarg1;
67263   arg2 = (Dali::Toolkit::Control *)jarg2;
67264   if (!arg2) {
67265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67266     return 0;
67267   }
67268   {
67269     try {
67270       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67271     } catch (std::out_of_range& e) {
67272       {
67273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67274       };
67275     } catch (std::exception& e) {
67276       {
67277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67278       };
67279     } catch (Dali::DaliException e) {
67280       {
67281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67282       };
67283     } catch (...) {
67284       {
67285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67286       };
67287     }
67288   }
67289
67290   jresult = (void *)result;
67291   return jresult;
67292 }
67293
67294
67295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67296   void * jresult ;
67297   Dali::BaseHandle arg1 ;
67298   Dali::BaseHandle *argp1 ;
67299   Dali::Toolkit::Control result;
67300
67301   argp1 = (Dali::BaseHandle *)jarg1;
67302   if (!argp1) {
67303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67304     return 0;
67305   }
67306   arg1 = *argp1;
67307   {
67308     try {
67309       result = Dali::Toolkit::Control::DownCast(arg1);
67310     } catch (std::out_of_range& e) {
67311       {
67312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67313       };
67314     } catch (std::exception& e) {
67315       {
67316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67317       };
67318     } catch (Dali::DaliException e) {
67319       {
67320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67321       };
67322     } catch (...) {
67323       {
67324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67325       };
67326     }
67327   }
67328
67329   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67330   return jresult;
67331 }
67332
67333
67334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67335   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67336
67337   arg1 = (Dali::Toolkit::Control *)jarg1;
67338   {
67339     try {
67340       (arg1)->SetKeyInputFocus();
67341     } catch (std::out_of_range& e) {
67342       {
67343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67344       };
67345     } catch (std::exception& e) {
67346       {
67347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67348       };
67349     } catch (Dali::DaliException e) {
67350       {
67351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67352       };
67353     } catch (...) {
67354       {
67355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67356       };
67357     }
67358   }
67359
67360 }
67361
67362
67363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67364   unsigned int jresult ;
67365   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67366   bool result;
67367
67368   arg1 = (Dali::Toolkit::Control *)jarg1;
67369   {
67370     try {
67371       result = (bool)(arg1)->HasKeyInputFocus();
67372     } catch (std::out_of_range& e) {
67373       {
67374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67375       };
67376     } catch (std::exception& e) {
67377       {
67378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67379       };
67380     } catch (Dali::DaliException e) {
67381       {
67382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67383       };
67384     } catch (...) {
67385       {
67386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67387       };
67388     }
67389   }
67390
67391   jresult = result;
67392   return jresult;
67393 }
67394
67395
67396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67397   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67398
67399   arg1 = (Dali::Toolkit::Control *)jarg1;
67400   {
67401     try {
67402       (arg1)->ClearKeyInputFocus();
67403     } catch (std::out_of_range& e) {
67404       {
67405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67406       };
67407     } catch (std::exception& e) {
67408       {
67409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67410       };
67411     } catch (Dali::DaliException e) {
67412       {
67413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67414       };
67415     } catch (...) {
67416       {
67417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67418       };
67419     }
67420   }
67421
67422 }
67423
67424
67425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67426   void * jresult ;
67427   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67428   Dali::PinchGestureDetector result;
67429
67430   arg1 = (Dali::Toolkit::Control *)jarg1;
67431   {
67432     try {
67433       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67434     } catch (std::out_of_range& e) {
67435       {
67436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67437       };
67438     } catch (std::exception& e) {
67439       {
67440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67441       };
67442     } catch (Dali::DaliException e) {
67443       {
67444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67445       };
67446     } catch (...) {
67447       {
67448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67449       };
67450     }
67451   }
67452
67453   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67454   return jresult;
67455 }
67456
67457
67458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67459   void * jresult ;
67460   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67461   Dali::PanGestureDetector result;
67462
67463   arg1 = (Dali::Toolkit::Control *)jarg1;
67464   {
67465     try {
67466       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67467     } catch (std::out_of_range& e) {
67468       {
67469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67470       };
67471     } catch (std::exception& e) {
67472       {
67473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67474       };
67475     } catch (Dali::DaliException e) {
67476       {
67477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67478       };
67479     } catch (...) {
67480       {
67481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67482       };
67483     }
67484   }
67485
67486   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67487   return jresult;
67488 }
67489
67490
67491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67492   void * jresult ;
67493   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67494   Dali::TapGestureDetector result;
67495
67496   arg1 = (Dali::Toolkit::Control *)jarg1;
67497   {
67498     try {
67499       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67500     } catch (std::out_of_range& e) {
67501       {
67502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67503       };
67504     } catch (std::exception& e) {
67505       {
67506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67507       };
67508     } catch (Dali::DaliException e) {
67509       {
67510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67511       };
67512     } catch (...) {
67513       {
67514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67515       };
67516     }
67517   }
67518
67519   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67520   return jresult;
67521 }
67522
67523
67524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67525   void * jresult ;
67526   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67527   Dali::LongPressGestureDetector result;
67528
67529   arg1 = (Dali::Toolkit::Control *)jarg1;
67530   {
67531     try {
67532       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67533     } catch (std::out_of_range& e) {
67534       {
67535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67536       };
67537     } catch (std::exception& e) {
67538       {
67539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67540       };
67541     } catch (Dali::DaliException e) {
67542       {
67543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67544       };
67545     } catch (...) {
67546       {
67547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67548       };
67549     }
67550   }
67551
67552   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67553   return jresult;
67554 }
67555
67556
67557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67558   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67559   std::string *arg2 = 0 ;
67560
67561   arg1 = (Dali::Toolkit::Control *)jarg1;
67562   if (!jarg2) {
67563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67564     return ;
67565   }
67566   std::string arg2_str(jarg2);
67567   arg2 = &arg2_str;
67568   {
67569     try {
67570       (arg1)->SetStyleName((std::string const &)*arg2);
67571     } catch (std::out_of_range& e) {
67572       {
67573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67574       };
67575     } catch (std::exception& e) {
67576       {
67577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67578       };
67579     } catch (Dali::DaliException e) {
67580       {
67581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67582       };
67583     } catch (...) {
67584       {
67585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67586       };
67587     }
67588   }
67589
67590
67591   //argout typemap for const std::string&
67592
67593 }
67594
67595
67596 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67597   char * jresult ;
67598   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67599   std::string *result = 0 ;
67600
67601   arg1 = (Dali::Toolkit::Control *)jarg1;
67602   {
67603     try {
67604       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67605     } catch (std::out_of_range& e) {
67606       {
67607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67608       };
67609     } catch (std::exception& e) {
67610       {
67611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67612       };
67613     } catch (Dali::DaliException e) {
67614       {
67615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67616       };
67617     } catch (...) {
67618       {
67619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67620       };
67621     }
67622   }
67623
67624   jresult = SWIG_csharp_string_callback(result->c_str());
67625   return jresult;
67626 }
67627
67628
67629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67630   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67631   Dali::Vector4 *arg2 = 0 ;
67632
67633   arg1 = (Dali::Toolkit::Control *)jarg1;
67634   arg2 = (Dali::Vector4 *)jarg2;
67635   if (!arg2) {
67636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67637     return ;
67638   }
67639   {
67640     try {
67641       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67642     } catch (std::out_of_range& e) {
67643       {
67644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67645       };
67646     } catch (std::exception& e) {
67647       {
67648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67649       };
67650     } catch (Dali::DaliException e) {
67651       {
67652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67653       };
67654     } catch (...) {
67655       {
67656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67657       };
67658     }
67659   }
67660
67661 }
67662
67663
67664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67665   void * jresult ;
67666   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67667   Dali::Vector4 result;
67668
67669   arg1 = (Dali::Toolkit::Control *)jarg1;
67670   {
67671     try {
67672       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67673     } catch (std::out_of_range& e) {
67674       {
67675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67676       };
67677     } catch (std::exception& e) {
67678       {
67679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67680       };
67681     } catch (Dali::DaliException e) {
67682       {
67683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67684       };
67685     } catch (...) {
67686       {
67687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67688       };
67689     }
67690   }
67691
67692   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67693   return jresult;
67694 }
67695
67696
67697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67698   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67699   Dali::Image arg2 ;
67700   Dali::Image *argp2 ;
67701
67702   arg1 = (Dali::Toolkit::Control *)jarg1;
67703   argp2 = (Dali::Image *)jarg2;
67704   if (!argp2) {
67705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67706     return ;
67707   }
67708   arg2 = *argp2;
67709   {
67710     try {
67711       (arg1)->SetBackgroundImage(arg2);
67712     } catch (std::out_of_range& e) {
67713       {
67714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67715       };
67716     } catch (std::exception& e) {
67717       {
67718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67719       };
67720     } catch (Dali::DaliException e) {
67721       {
67722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67723       };
67724     } catch (...) {
67725       {
67726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67727       };
67728     }
67729   }
67730
67731 }
67732
67733
67734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67735   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67736
67737   arg1 = (Dali::Toolkit::Control *)jarg1;
67738   {
67739     try {
67740       (arg1)->ClearBackground();
67741     } catch (std::out_of_range& e) {
67742       {
67743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67744       };
67745     } catch (std::exception& e) {
67746       {
67747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67748       };
67749     } catch (Dali::DaliException e) {
67750       {
67751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67752       };
67753     } catch (...) {
67754       {
67755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67756       };
67757     }
67758   }
67759
67760 }
67761
67762
67763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67764   void * jresult ;
67765   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67766   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67767
67768   arg1 = (Dali::Toolkit::Control *)jarg1;
67769   {
67770     try {
67771       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67772     } catch (std::out_of_range& e) {
67773       {
67774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67775       };
67776     } catch (std::exception& e) {
67777       {
67778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67779       };
67780     } catch (Dali::DaliException e) {
67781       {
67782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67783       };
67784     } catch (...) {
67785       {
67786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67787       };
67788     }
67789   }
67790
67791   jresult = (void *)result;
67792   return jresult;
67793 }
67794
67795
67796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67797   void * jresult ;
67798   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67799   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67800
67801   arg1 = (Dali::Toolkit::Control *)jarg1;
67802   {
67803     try {
67804       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67805     } catch (std::out_of_range& e) {
67806       {
67807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67808       };
67809     } catch (std::exception& e) {
67810       {
67811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67812       };
67813     } catch (Dali::DaliException e) {
67814       {
67815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67816       };
67817     } catch (...) {
67818       {
67819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67820       };
67821     }
67822   }
67823
67824   jresult = (void *)result;
67825   return jresult;
67826 }
67827
67828
67829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67830   void * jresult ;
67831   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67832   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67833
67834   arg1 = (Dali::Toolkit::Control *)jarg1;
67835   {
67836     try {
67837       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67838     } catch (std::out_of_range& e) {
67839       {
67840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67841       };
67842     } catch (std::exception& e) {
67843       {
67844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67845       };
67846     } catch (Dali::DaliException e) {
67847       {
67848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67849       };
67850     } catch (...) {
67851       {
67852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67853       };
67854     }
67855   }
67856
67857   jresult = (void *)result;
67858   return jresult;
67859 }
67860
67861
67862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67863   void * jresult ;
67864   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67865   Dali::Toolkit::Control *result = 0 ;
67866
67867   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67868   if (!arg1) {
67869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67870     return 0;
67871   }
67872   {
67873     try {
67874       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67875     } catch (std::out_of_range& e) {
67876       {
67877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67878       };
67879     } catch (std::exception& e) {
67880       {
67881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67882       };
67883     } catch (Dali::DaliException e) {
67884       {
67885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67886       };
67887     } catch (...) {
67888       {
67889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67890       };
67891     }
67892   }
67893
67894   jresult = (void *)result;
67895   return jresult;
67896 }
67897
67898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67899 {
67900   int jresult;
67901   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67902   arg1 = (Dali::Toolkit::Control *)jarg1;
67903
67904   if (!arg1) {
67905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67906     return 0;
67907   }
67908
67909   Dali::Property::Index arg2 = 0 ;
67910   arg2 = (Dali::Property::Index)jarg2;
67911
67912   Toolkit::Visual::ResourceStatus result;
67913   {
67914     try {
67915       result = arg1->GetVisualResourceStatus(arg2);
67916     } catch (std::out_of_range& e) {
67917       {
67918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67919       };
67920     } catch (std::exception& e) {
67921       {
67922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67923       };
67924     } catch (...) {
67925       {
67926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67927       };
67928     }
67929   }
67930   jresult = (int)(result);
67931   return jresult;
67932 }
67933
67934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67935 {
67936   void * jresult;
67937   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67938   arg1 = (Dali::Toolkit::Control *)jarg1;
67939
67940   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67941
67942   Dali::Toolkit::TransitionData *arg2 = 0 ;
67943   Dali::Animation result;
67944
67945   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67946   if (!arg2) {
67947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67948     return 0;
67949   }
67950   {
67951     try {
67952       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67953     } catch (std::out_of_range& e) {
67954       {
67955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67956       };
67957     } catch (std::exception& e) {
67958       {
67959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67960       };
67961     } catch (Dali::DaliException e) {
67962       {
67963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67964       };
67965     } catch (...) {
67966       {
67967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67968       };
67969     }
67970   }
67971
67972   jresult = new Dali::Animation((const Dali::Animation &)result);
67973   return jresult;
67974 }
67975
67976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67977 {
67978   Dali::Toolkit::Control arg1;
67979   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67980
67981   if (!argp1) {
67982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67983   }
67984   arg1 = *argp1;
67985
67986   Dali::Property::Index arg2 = 0 ;
67987   arg2 = (Dali::Property::Index)jarg2;
67988
67989   Dali::Property::Index arg3 = 0 ;
67990   arg3 = (Dali::Property::Index)jarg3;
67991
67992   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
67993
67994   {
67995     try {
67996       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
67997     } catch (std::out_of_range& e) {
67998       {
67999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68000       };
68001     } catch (std::exception& e) {
68002       {
68003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68004       };
68005     } catch (...) {
68006       {
68007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68008       };
68009     }
68010   }
68011
68012
68013 }
68014
68015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
68016   void * jresult ;
68017   Dali::Toolkit::Control *arg1 = 0 ;
68018   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
68019
68020   arg1 = (Dali::Toolkit::Control *)jarg1;
68021   if (!arg1) {
68022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
68023     return 0;
68024   }
68025   {
68026     try {
68027       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
68028     } catch (std::out_of_range& e) {
68029       {
68030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68031       };
68032     } catch (std::exception& e) {
68033       {
68034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68035       };
68036     } catch (Dali::DaliException e) {
68037       {
68038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68039       };
68040     } catch (...) {
68041       {
68042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68043       };
68044     }
68045   }
68046
68047   jresult = (void *)result;
68048   return jresult;
68049 }
68050
68051
68052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68053   unsigned int jresult ;
68054   Dali::Toolkit::Control *arg1 = 0 ;
68055   bool result;
68056
68057   arg1 = (Dali::Toolkit::Control *)jarg1;
68058   if (!arg1) {
68059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68060     return 0;
68061   }
68062   {
68063     try {
68064       result = (bool)arg1->IsResourceReady();
68065     } catch (std::out_of_range& e) {
68066       {
68067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68068       };
68069     } catch (std::exception& e) {
68070       {
68071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68072       };
68073     } catch (Dali::DaliException e) {
68074       {
68075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68076       };
68077     } catch (...) {
68078       {
68079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68080       };
68081     }
68082   }
68083
68084   jresult = result;
68085   return jresult;
68086 }
68087
68088
68089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68090   void * jresult ;
68091   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68092
68093   {
68094     try {
68095       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68096     } catch (std::out_of_range& e) {
68097       {
68098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68099       };
68100     } catch (std::exception& e) {
68101       {
68102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68103       };
68104     } catch (Dali::DaliException e) {
68105       {
68106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68107       };
68108     } catch (...) {
68109       {
68110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68111       };
68112     }
68113   }
68114
68115   jresult = (void *)result;
68116   return jresult;
68117 }
68118
68119
68120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68121   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68122
68123   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68124   {
68125     try {
68126       delete arg1;
68127     } catch (std::out_of_range& e) {
68128       {
68129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68130       };
68131     } catch (std::exception& e) {
68132       {
68133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68134       };
68135     } catch (Dali::DaliException e) {
68136       {
68137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68138       };
68139     } catch (...) {
68140       {
68141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68142       };
68143     }
68144   }
68145
68146 }
68147
68148
68149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68150   void * jresult ;
68151   Dali::Toolkit::KeyInputFocusManager result;
68152
68153   {
68154     try {
68155       result = Dali::Toolkit::KeyInputFocusManager::Get();
68156     } catch (std::out_of_range& e) {
68157       {
68158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68159       };
68160     } catch (std::exception& e) {
68161       {
68162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68163       };
68164     } catch (Dali::DaliException e) {
68165       {
68166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68167       };
68168     } catch (...) {
68169       {
68170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68171       };
68172     }
68173   }
68174
68175   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68176   return jresult;
68177 }
68178
68179
68180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68181   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68182   Dali::Toolkit::Control arg2 ;
68183   Dali::Toolkit::Control *argp2 ;
68184
68185   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68186   argp2 = (Dali::Toolkit::Control *)jarg2;
68187   if (!argp2) {
68188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68189     return ;
68190   }
68191   arg2 = *argp2;
68192   {
68193     try {
68194       (arg1)->SetFocus(arg2);
68195     } catch (std::out_of_range& e) {
68196       {
68197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68198       };
68199     } catch (std::exception& e) {
68200       {
68201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68202       };
68203     } catch (Dali::DaliException e) {
68204       {
68205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68206       };
68207     } catch (...) {
68208       {
68209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68210       };
68211     }
68212   }
68213
68214 }
68215
68216
68217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68218   void * jresult ;
68219   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68220   Dali::Toolkit::Control result;
68221
68222   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68223   {
68224     try {
68225       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68226     } catch (std::out_of_range& e) {
68227       {
68228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68229       };
68230     } catch (std::exception& e) {
68231       {
68232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68233       };
68234     } catch (Dali::DaliException e) {
68235       {
68236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68237       };
68238     } catch (...) {
68239       {
68240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68241       };
68242     }
68243   }
68244
68245   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68246   return jresult;
68247 }
68248
68249
68250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68251   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68252   Dali::Toolkit::Control arg2 ;
68253   Dali::Toolkit::Control *argp2 ;
68254
68255   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68256   argp2 = (Dali::Toolkit::Control *)jarg2;
68257   if (!argp2) {
68258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68259     return ;
68260   }
68261   arg2 = *argp2;
68262   {
68263     try {
68264       (arg1)->RemoveFocus(arg2);
68265     } catch (std::out_of_range& e) {
68266       {
68267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68268       };
68269     } catch (std::exception& e) {
68270       {
68271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68272       };
68273     } catch (Dali::DaliException e) {
68274       {
68275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68276       };
68277     } catch (...) {
68278       {
68279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68280       };
68281     }
68282   }
68283
68284 }
68285
68286
68287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68288   void * jresult ;
68289   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68290   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68291
68292   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68293   {
68294     try {
68295       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68296     } catch (std::out_of_range& e) {
68297       {
68298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68299       };
68300     } catch (std::exception& e) {
68301       {
68302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68303       };
68304     } catch (Dali::DaliException e) {
68305       {
68306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68307       };
68308     } catch (...) {
68309       {
68310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68311       };
68312     }
68313   }
68314
68315   jresult = (void *)result;
68316   return jresult;
68317 }
68318
68319
68320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68321   void * jresult ;
68322   Dali::Toolkit::Alignment::Padding *result = 0 ;
68323
68324   {
68325     try {
68326       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68327     } catch (std::out_of_range& e) {
68328       {
68329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68330       };
68331     } catch (std::exception& e) {
68332       {
68333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68334       };
68335     } catch (Dali::DaliException e) {
68336       {
68337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68338       };
68339     } catch (...) {
68340       {
68341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68342       };
68343     }
68344   }
68345
68346   jresult = (void *)result;
68347   return jresult;
68348 }
68349
68350
68351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68352   void * jresult ;
68353   float arg1 ;
68354   float arg2 ;
68355   float arg3 ;
68356   float arg4 ;
68357   Dali::Toolkit::Alignment::Padding *result = 0 ;
68358
68359   arg1 = (float)jarg1;
68360   arg2 = (float)jarg2;
68361   arg3 = (float)jarg3;
68362   arg4 = (float)jarg4;
68363   {
68364     try {
68365       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68366     } catch (std::out_of_range& e) {
68367       {
68368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68369       };
68370     } catch (std::exception& e) {
68371       {
68372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68373       };
68374     } catch (Dali::DaliException e) {
68375       {
68376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68377       };
68378     } catch (...) {
68379       {
68380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68381       };
68382     }
68383   }
68384
68385   jresult = (void *)result;
68386   return jresult;
68387 }
68388
68389
68390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68391   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68392   float arg2 ;
68393
68394   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68395   arg2 = (float)jarg2;
68396   if (arg1) (arg1)->left = arg2;
68397 }
68398
68399
68400 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68401   float jresult ;
68402   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68403   float result;
68404
68405   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68406   result = (float) ((arg1)->left);
68407   jresult = result;
68408   return jresult;
68409 }
68410
68411
68412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68413   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68414   float arg2 ;
68415
68416   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68417   arg2 = (float)jarg2;
68418   if (arg1) (arg1)->right = arg2;
68419 }
68420
68421
68422 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68423   float jresult ;
68424   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68425   float result;
68426
68427   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68428   result = (float) ((arg1)->right);
68429   jresult = result;
68430   return jresult;
68431 }
68432
68433
68434 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68435   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68436   float arg2 ;
68437
68438   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68439   arg2 = (float)jarg2;
68440   if (arg1) (arg1)->top = arg2;
68441 }
68442
68443
68444 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68445   float jresult ;
68446   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68447   float result;
68448
68449   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68450   result = (float) ((arg1)->top);
68451   jresult = result;
68452   return jresult;
68453 }
68454
68455
68456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68457   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68458   float arg2 ;
68459
68460   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68461   arg2 = (float)jarg2;
68462   if (arg1) (arg1)->bottom = arg2;
68463 }
68464
68465
68466 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68467   float jresult ;
68468   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68469   float result;
68470
68471   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68472   result = (float) ((arg1)->bottom);
68473   jresult = result;
68474   return jresult;
68475 }
68476
68477
68478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68479   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68480
68481   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68482   {
68483     try {
68484       delete arg1;
68485     } catch (std::out_of_range& e) {
68486       {
68487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68488       };
68489     } catch (std::exception& e) {
68490       {
68491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68492       };
68493     } catch (Dali::DaliException e) {
68494       {
68495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68496       };
68497     } catch (...) {
68498       {
68499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68500       };
68501     }
68502   }
68503
68504 }
68505
68506
68507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68508   void * jresult ;
68509   Dali::Toolkit::Alignment *result = 0 ;
68510
68511   {
68512     try {
68513       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68514     } catch (std::out_of_range& e) {
68515       {
68516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68517       };
68518     } catch (std::exception& e) {
68519       {
68520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68521       };
68522     } catch (Dali::DaliException e) {
68523       {
68524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68525       };
68526     } catch (...) {
68527       {
68528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68529       };
68530     }
68531   }
68532
68533   jresult = (void *)result;
68534   return jresult;
68535 }
68536
68537
68538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68539   void * jresult ;
68540   Dali::Toolkit::Alignment::Type arg1 ;
68541   Dali::Toolkit::Alignment::Type arg2 ;
68542   Dali::Toolkit::Alignment result;
68543
68544   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68545   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68546   {
68547     try {
68548       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68549     } catch (std::out_of_range& e) {
68550       {
68551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68552       };
68553     } catch (std::exception& e) {
68554       {
68555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68556       };
68557     } catch (Dali::DaliException e) {
68558       {
68559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68560       };
68561     } catch (...) {
68562       {
68563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68564       };
68565     }
68566   }
68567
68568   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68569   return jresult;
68570 }
68571
68572
68573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68574   void * jresult ;
68575   Dali::Toolkit::Alignment::Type arg1 ;
68576   Dali::Toolkit::Alignment result;
68577
68578   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68579   {
68580     try {
68581       result = Dali::Toolkit::Alignment::New(arg1);
68582     } catch (std::out_of_range& e) {
68583       {
68584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68585       };
68586     } catch (std::exception& e) {
68587       {
68588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68589       };
68590     } catch (Dali::DaliException e) {
68591       {
68592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68593       };
68594     } catch (...) {
68595       {
68596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68597       };
68598     }
68599   }
68600
68601   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68602   return jresult;
68603 }
68604
68605
68606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68607   void * jresult ;
68608   Dali::Toolkit::Alignment result;
68609
68610   {
68611     try {
68612       result = Dali::Toolkit::Alignment::New();
68613     } catch (std::out_of_range& e) {
68614       {
68615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68616       };
68617     } catch (std::exception& e) {
68618       {
68619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68620       };
68621     } catch (Dali::DaliException e) {
68622       {
68623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68624       };
68625     } catch (...) {
68626       {
68627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68628       };
68629     }
68630   }
68631
68632   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68633   return jresult;
68634 }
68635
68636
68637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68638   void * jresult ;
68639   Dali::Toolkit::Alignment *arg1 = 0 ;
68640   Dali::Toolkit::Alignment *result = 0 ;
68641
68642   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68643   if (!arg1) {
68644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68645     return 0;
68646   }
68647   {
68648     try {
68649       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68650     } catch (std::out_of_range& e) {
68651       {
68652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68653       };
68654     } catch (std::exception& e) {
68655       {
68656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68657       };
68658     } catch (Dali::DaliException e) {
68659       {
68660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68661       };
68662     } catch (...) {
68663       {
68664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68665       };
68666     }
68667   }
68668
68669   jresult = (void *)result;
68670   return jresult;
68671 }
68672
68673
68674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68675   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68676
68677   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68678   {
68679     try {
68680       delete arg1;
68681     } catch (std::out_of_range& e) {
68682       {
68683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68684       };
68685     } catch (std::exception& e) {
68686       {
68687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68688       };
68689     } catch (Dali::DaliException e) {
68690       {
68691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68692       };
68693     } catch (...) {
68694       {
68695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68696       };
68697     }
68698   }
68699
68700 }
68701
68702
68703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68704   void * jresult ;
68705   Dali::BaseHandle arg1 ;
68706   Dali::BaseHandle *argp1 ;
68707   Dali::Toolkit::Alignment result;
68708
68709   argp1 = (Dali::BaseHandle *)jarg1;
68710   if (!argp1) {
68711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68712     return 0;
68713   }
68714   arg1 = *argp1;
68715   {
68716     try {
68717       result = Dali::Toolkit::Alignment::DownCast(arg1);
68718     } catch (std::out_of_range& e) {
68719       {
68720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68721       };
68722     } catch (std::exception& e) {
68723       {
68724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68725       };
68726     } catch (Dali::DaliException e) {
68727       {
68728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68729       };
68730     } catch (...) {
68731       {
68732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68733       };
68734     }
68735   }
68736
68737   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68738   return jresult;
68739 }
68740
68741
68742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68743   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68744   Dali::Toolkit::Alignment::Type arg2 ;
68745
68746   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68747   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68748   {
68749     try {
68750       (arg1)->SetAlignmentType(arg2);
68751     } catch (std::out_of_range& e) {
68752       {
68753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68754       };
68755     } catch (std::exception& e) {
68756       {
68757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68758       };
68759     } catch (Dali::DaliException e) {
68760       {
68761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68762       };
68763     } catch (...) {
68764       {
68765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68766       };
68767     }
68768   }
68769
68770 }
68771
68772
68773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68774   int jresult ;
68775   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68776   Dali::Toolkit::Alignment::Type result;
68777
68778   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68779   {
68780     try {
68781       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68782     } catch (std::out_of_range& e) {
68783       {
68784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68785       };
68786     } catch (std::exception& e) {
68787       {
68788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68789       };
68790     } catch (Dali::DaliException e) {
68791       {
68792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68793       };
68794     } catch (...) {
68795       {
68796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68797       };
68798     }
68799   }
68800
68801   jresult = (int)result;
68802   return jresult;
68803 }
68804
68805
68806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68807   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68808   Dali::Toolkit::Alignment::Scaling arg2 ;
68809
68810   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68811   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68812   {
68813     try {
68814       (arg1)->SetScaling(arg2);
68815     } catch (std::out_of_range& e) {
68816       {
68817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68818       };
68819     } catch (std::exception& e) {
68820       {
68821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68822       };
68823     } catch (Dali::DaliException e) {
68824       {
68825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68826       };
68827     } catch (...) {
68828       {
68829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68830       };
68831     }
68832   }
68833
68834 }
68835
68836
68837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68838   int jresult ;
68839   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68840   Dali::Toolkit::Alignment::Scaling result;
68841
68842   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68843   {
68844     try {
68845       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68846     } catch (std::out_of_range& e) {
68847       {
68848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68849       };
68850     } catch (std::exception& e) {
68851       {
68852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68853       };
68854     } catch (Dali::DaliException e) {
68855       {
68856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68857       };
68858     } catch (...) {
68859       {
68860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68861       };
68862     }
68863   }
68864
68865   jresult = (int)result;
68866   return jresult;
68867 }
68868
68869
68870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68871   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68872   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68873
68874   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68875   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68876   if (!arg2) {
68877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68878     return ;
68879   }
68880   {
68881     try {
68882       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68883     } catch (std::out_of_range& e) {
68884       {
68885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68886       };
68887     } catch (std::exception& e) {
68888       {
68889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68890       };
68891     } catch (Dali::DaliException e) {
68892       {
68893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68894       };
68895     } catch (...) {
68896       {
68897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68898       };
68899     }
68900   }
68901
68902 }
68903
68904
68905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68906   void * jresult ;
68907   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68908   Dali::Toolkit::Alignment::Padding *result = 0 ;
68909
68910   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68911   {
68912     try {
68913       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68914     } catch (std::out_of_range& e) {
68915       {
68916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68917       };
68918     } catch (std::exception& e) {
68919       {
68920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68921       };
68922     } catch (Dali::DaliException e) {
68923       {
68924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68925       };
68926     } catch (...) {
68927       {
68928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68929       };
68930     }
68931   }
68932
68933   jresult = (void *)result;
68934   return jresult;
68935 }
68936
68937
68938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68939   void * jresult ;
68940   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68941   Dali::Toolkit::Alignment *arg2 = 0 ;
68942   Dali::Toolkit::Alignment *result = 0 ;
68943
68944   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68945   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68946   if (!arg2) {
68947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68948     return 0;
68949   }
68950   {
68951     try {
68952       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68953     } catch (std::out_of_range& e) {
68954       {
68955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68956       };
68957     } catch (std::exception& e) {
68958       {
68959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68960       };
68961     } catch (Dali::DaliException e) {
68962       {
68963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68964       };
68965     } catch (...) {
68966       {
68967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68968       };
68969     }
68970   }
68971
68972   jresult = (void *)result;
68973   return jresult;
68974 }
68975
68976
68977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68978   int jresult ;
68979   int result;
68980
68981   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68982   jresult = (int)result;
68983   return jresult;
68984 }
68985
68986
68987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68988   int jresult ;
68989   int result;
68990
68991   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68992   jresult = (int)result;
68993   return jresult;
68994 }
68995
68996
68997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68998   int jresult ;
68999   int result;
69000
69001   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
69002   jresult = (int)result;
69003   return jresult;
69004 }
69005
69006
69007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
69008   int jresult ;
69009   int result;
69010
69011   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
69012   jresult = (int)result;
69013   return jresult;
69014 }
69015
69016
69017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
69018   int jresult ;
69019   int result;
69020
69021   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
69022   jresult = (int)result;
69023   return jresult;
69024 }
69025
69026
69027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
69028   int jresult ;
69029   int result;
69030
69031   result = (int)Dali::Toolkit::Button::Property::SELECTED;
69032   jresult = (int)result;
69033   return jresult;
69034 }
69035
69036
69037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69038   int jresult ;
69039   int result;
69040
69041   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69042   jresult = (int)result;
69043   return jresult;
69044 }
69045
69046
69047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69048   int jresult ;
69049   int result;
69050
69051   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69052   jresult = (int)result;
69053   return jresult;
69054 }
69055
69056
69057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69058   int jresult ;
69059   int result;
69060
69061   result = (int)Dali::Toolkit::Button::Property::LABEL;
69062   jresult = (int)result;
69063   return jresult;
69064 }
69065
69066
69067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69068   int jresult ;
69069   int result;
69070
69071   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69072   jresult = (int)result;
69073   return jresult;
69074 }
69075
69076
69077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69078   void * jresult ;
69079   Dali::Toolkit::Button::Property *result = 0 ;
69080
69081   {
69082     try {
69083       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69084     } catch (std::out_of_range& e) {
69085       {
69086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69087       };
69088     } catch (std::exception& e) {
69089       {
69090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69091       };
69092     } catch (Dali::DaliException e) {
69093       {
69094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69095       };
69096     } catch (...) {
69097       {
69098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69099       };
69100     }
69101   }
69102
69103   jresult = (void *)result;
69104   return jresult;
69105 }
69106
69107
69108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69109   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69110
69111   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69112   {
69113     try {
69114       delete arg1;
69115     } catch (std::out_of_range& e) {
69116       {
69117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69118       };
69119     } catch (std::exception& e) {
69120       {
69121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69122       };
69123     } catch (Dali::DaliException e) {
69124       {
69125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69126       };
69127     } catch (...) {
69128       {
69129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69130       };
69131     }
69132   }
69133
69134 }
69135
69136
69137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69138   void * jresult ;
69139   Dali::Toolkit::Button *result = 0 ;
69140
69141   {
69142     try {
69143       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69144     } catch (std::out_of_range& e) {
69145       {
69146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69147       };
69148     } catch (std::exception& e) {
69149       {
69150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69151       };
69152     } catch (Dali::DaliException e) {
69153       {
69154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69155       };
69156     } catch (...) {
69157       {
69158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69159       };
69160     }
69161   }
69162
69163   jresult = (void *)result;
69164   return jresult;
69165 }
69166
69167
69168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69169   void * jresult ;
69170   Dali::Toolkit::Button *arg1 = 0 ;
69171   Dali::Toolkit::Button *result = 0 ;
69172
69173   arg1 = (Dali::Toolkit::Button *)jarg1;
69174   if (!arg1) {
69175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69176     return 0;
69177   }
69178   {
69179     try {
69180       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69181     } catch (std::out_of_range& e) {
69182       {
69183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69184       };
69185     } catch (std::exception& e) {
69186       {
69187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69188       };
69189     } catch (Dali::DaliException e) {
69190       {
69191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69192       };
69193     } catch (...) {
69194       {
69195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69196       };
69197     }
69198   }
69199
69200   jresult = (void *)result;
69201   return jresult;
69202 }
69203
69204
69205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69206   void * jresult ;
69207   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69208   Dali::Toolkit::Button *arg2 = 0 ;
69209   Dali::Toolkit::Button *result = 0 ;
69210
69211   arg1 = (Dali::Toolkit::Button *)jarg1;
69212   arg2 = (Dali::Toolkit::Button *)jarg2;
69213   if (!arg2) {
69214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69215     return 0;
69216   }
69217   {
69218     try {
69219       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69220     } catch (std::out_of_range& e) {
69221       {
69222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69223       };
69224     } catch (std::exception& e) {
69225       {
69226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69227       };
69228     } catch (Dali::DaliException e) {
69229       {
69230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69231       };
69232     } catch (...) {
69233       {
69234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69235       };
69236     }
69237   }
69238
69239   jresult = (void *)result;
69240   return jresult;
69241 }
69242
69243
69244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69245   void * jresult ;
69246   Dali::BaseHandle arg1 ;
69247   Dali::BaseHandle *argp1 ;
69248   Dali::Toolkit::Button result;
69249
69250   argp1 = (Dali::BaseHandle *)jarg1;
69251   if (!argp1) {
69252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69253     return 0;
69254   }
69255   arg1 = *argp1;
69256   {
69257     try {
69258       result = Dali::Toolkit::Button::DownCast(arg1);
69259     } catch (std::out_of_range& e) {
69260       {
69261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69262       };
69263     } catch (std::exception& e) {
69264       {
69265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69266       };
69267     } catch (Dali::DaliException e) {
69268       {
69269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69270       };
69271     } catch (...) {
69272       {
69273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69274       };
69275     }
69276   }
69277
69278   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69279   return jresult;
69280 }
69281
69282
69283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69284   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69285
69286   arg1 = (Dali::Toolkit::Button *)jarg1;
69287   {
69288     try {
69289       delete arg1;
69290     } catch (std::out_of_range& e) {
69291       {
69292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69293       };
69294     } catch (std::exception& e) {
69295       {
69296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69297       };
69298     } catch (Dali::DaliException e) {
69299       {
69300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69301       };
69302     } catch (...) {
69303       {
69304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69305       };
69306     }
69307   }
69308
69309 }
69310
69311
69312 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69313   unsigned int jresult ;
69314   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69315   bool result;
69316
69317   arg1 = (Dali::Toolkit::Button *)jarg1;
69318   {
69319     try {
69320       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69321     } catch (std::out_of_range& e) {
69322       {
69323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69324       };
69325     } catch (std::exception& e) {
69326       {
69327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69328       };
69329     } catch (Dali::DaliException e) {
69330       {
69331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69332       };
69333     } catch (...) {
69334       {
69335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69336       };
69337     }
69338   }
69339
69340   jresult = result;
69341   return jresult;
69342 }
69343
69344
69345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69346   unsigned int jresult ;
69347   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69348   bool result;
69349
69350   arg1 = (Dali::Toolkit::Button *)jarg1;
69351   {
69352     try {
69353       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69354     } catch (std::out_of_range& e) {
69355       {
69356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69357       };
69358     } catch (std::exception& e) {
69359       {
69360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69361       };
69362     } catch (Dali::DaliException e) {
69363       {
69364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69365       };
69366     } catch (...) {
69367       {
69368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69369       };
69370     }
69371   }
69372
69373   jresult = result;
69374   return jresult;
69375 }
69376
69377
69378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69379   float jresult ;
69380   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69381   float result;
69382
69383   arg1 = (Dali::Toolkit::Button *)jarg1;
69384   {
69385     try {
69386       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69387     } catch (std::out_of_range& e) {
69388       {
69389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69390       };
69391     } catch (std::exception& e) {
69392       {
69393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69394       };
69395     } catch (Dali::DaliException e) {
69396       {
69397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69398       };
69399     } catch (...) {
69400       {
69401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69402       };
69403     }
69404   }
69405
69406   jresult = result;
69407   return jresult;
69408 }
69409
69410
69411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69412   float jresult ;
69413   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69414   float result;
69415
69416   arg1 = (Dali::Toolkit::Button *)jarg1;
69417   {
69418     try {
69419       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69420     } catch (std::out_of_range& e) {
69421       {
69422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69423       };
69424     } catch (std::exception& e) {
69425       {
69426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69427       };
69428     } catch (Dali::DaliException e) {
69429       {
69430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69431       };
69432     } catch (...) {
69433       {
69434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69435       };
69436     }
69437   }
69438
69439   jresult = result;
69440   return jresult;
69441 }
69442
69443
69444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69445   unsigned int jresult ;
69446   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69447   bool result;
69448
69449   arg1 = (Dali::Toolkit::Button *)jarg1;
69450   {
69451     try {
69452       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69453     } catch (std::out_of_range& e) {
69454       {
69455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69456       };
69457     } catch (std::exception& e) {
69458       {
69459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69460       };
69461     } catch (Dali::DaliException e) {
69462       {
69463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69464       };
69465     } catch (...) {
69466       {
69467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69468       };
69469     }
69470   }
69471
69472   jresult = result;
69473   return jresult;
69474 }
69475
69476
69477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69478   unsigned int jresult ;
69479   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69480   bool result;
69481
69482   arg1 = (Dali::Toolkit::Button *)jarg1;
69483   {
69484     try {
69485       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69486     } catch (std::out_of_range& e) {
69487       {
69488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69489       };
69490     } catch (std::exception& e) {
69491       {
69492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69493       };
69494     } catch (Dali::DaliException e) {
69495       {
69496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69497       };
69498     } catch (...) {
69499       {
69500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69501       };
69502     }
69503   }
69504
69505   jresult = result;
69506   return jresult;
69507 }
69508
69509
69510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69511   float jresult ;
69512   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69513   float result;
69514
69515   arg1 = (Dali::Toolkit::Button *)jarg1;
69516   {
69517     try {
69518       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69519     } catch (std::out_of_range& e) {
69520       {
69521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69522       };
69523     } catch (std::exception& e) {
69524       {
69525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69526       };
69527     } catch (Dali::DaliException e) {
69528       {
69529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69530       };
69531     } catch (...) {
69532       {
69533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69534       };
69535     }
69536   }
69537
69538   jresult = result;
69539   return jresult;
69540 }
69541
69542
69543 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69544   char * jresult ;
69545   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69546   std::string result;
69547
69548   arg1 = (Dali::Toolkit::Button *)jarg1;
69549   {
69550     try {
69551       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69552     } catch (std::out_of_range& e) {
69553       {
69554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69555       };
69556     } catch (std::exception& e) {
69557       {
69558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69559       };
69560     } catch (Dali::DaliException e) {
69561       {
69562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69563       };
69564     } catch (...) {
69565       {
69566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69567       };
69568     }
69569   }
69570
69571   jresult = SWIG_csharp_string_callback((&result)->c_str());
69572   return jresult;
69573 }
69574
69575
69576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69577   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69578   Dali::Actor arg2 ;
69579   Dali::Actor *argp2 ;
69580
69581   arg1 = (Dali::Toolkit::Button *)jarg1;
69582   argp2 = (Dali::Actor *)jarg2;
69583   if (!argp2) {
69584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69585     return ;
69586   }
69587   arg2 = *argp2;
69588   {
69589     try {
69590       (arg1)->SetLabel(arg2);
69591     } catch (std::out_of_range& e) {
69592       {
69593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69594       };
69595     } catch (std::exception& e) {
69596       {
69597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69598       };
69599     } catch (Dali::DaliException e) {
69600       {
69601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69602       };
69603     } catch (...) {
69604       {
69605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69606       };
69607     }
69608   }
69609
69610 }
69611
69612
69613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69614   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69615   Dali::Image arg2 ;
69616   Dali::Image *argp2 ;
69617
69618   arg1 = (Dali::Toolkit::Button *)jarg1;
69619   argp2 = (Dali::Image *)jarg2;
69620   if (!argp2) {
69621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69622     return ;
69623   }
69624   arg2 = *argp2;
69625   {
69626     try {
69627       (arg1)->SetButtonImage(arg2);
69628     } catch (std::out_of_range& e) {
69629       {
69630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69631       };
69632     } catch (std::exception& e) {
69633       {
69634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69635       };
69636     } catch (Dali::DaliException e) {
69637       {
69638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69639       };
69640     } catch (...) {
69641       {
69642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69643       };
69644     }
69645   }
69646
69647 }
69648
69649
69650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69651   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69652   Dali::Image arg2 ;
69653   Dali::Image *argp2 ;
69654
69655   arg1 = (Dali::Toolkit::Button *)jarg1;
69656   argp2 = (Dali::Image *)jarg2;
69657   if (!argp2) {
69658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69659     return ;
69660   }
69661   arg2 = *argp2;
69662   {
69663     try {
69664       (arg1)->SetSelectedImage(arg2);
69665     } catch (std::out_of_range& e) {
69666       {
69667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69668       };
69669     } catch (std::exception& e) {
69670       {
69671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69672       };
69673     } catch (Dali::DaliException e) {
69674       {
69675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69676       };
69677     } catch (...) {
69678       {
69679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69680       };
69681     }
69682   }
69683
69684 }
69685
69686
69687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69688   void * jresult ;
69689   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69690   Dali::Actor result;
69691
69692   arg1 = (Dali::Toolkit::Button *)jarg1;
69693   {
69694     try {
69695       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69696     } catch (std::out_of_range& e) {
69697       {
69698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69699       };
69700     } catch (std::exception& e) {
69701       {
69702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69703       };
69704     } catch (Dali::DaliException e) {
69705       {
69706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69707       };
69708     } catch (...) {
69709       {
69710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69711       };
69712     }
69713   }
69714
69715   jresult = new Dali::Actor((const Dali::Actor &)result);
69716   return jresult;
69717 }
69718
69719
69720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69721   void * jresult ;
69722   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69723   Dali::Actor result;
69724
69725   arg1 = (Dali::Toolkit::Button *)jarg1;
69726   {
69727     try {
69728       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69729     } catch (std::out_of_range& e) {
69730       {
69731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69732       };
69733     } catch (std::exception& e) {
69734       {
69735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69736       };
69737     } catch (Dali::DaliException e) {
69738       {
69739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69740       };
69741     } catch (...) {
69742       {
69743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69744       };
69745     }
69746   }
69747
69748   jresult = new Dali::Actor((const Dali::Actor &)result);
69749   return jresult;
69750 }
69751
69752
69753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69754   void * jresult ;
69755   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69756   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69757
69758   arg1 = (Dali::Toolkit::Button *)jarg1;
69759   {
69760     try {
69761       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69762     } catch (std::out_of_range& e) {
69763       {
69764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69765       };
69766     } catch (std::exception& e) {
69767       {
69768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69769       };
69770     } catch (Dali::DaliException e) {
69771       {
69772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69773       };
69774     } catch (...) {
69775       {
69776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69777       };
69778     }
69779   }
69780
69781   jresult = (void *)result;
69782   return jresult;
69783 }
69784
69785
69786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69787   void * jresult ;
69788   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69789   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69790
69791   arg1 = (Dali::Toolkit::Button *)jarg1;
69792   {
69793     try {
69794       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69795     } catch (std::out_of_range& e) {
69796       {
69797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69798       };
69799     } catch (std::exception& e) {
69800       {
69801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69802       };
69803     } catch (Dali::DaliException e) {
69804       {
69805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69806       };
69807     } catch (...) {
69808       {
69809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69810       };
69811     }
69812   }
69813
69814   jresult = (void *)result;
69815   return jresult;
69816 }
69817
69818
69819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69820   void * jresult ;
69821   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69822   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69823
69824   arg1 = (Dali::Toolkit::Button *)jarg1;
69825   {
69826     try {
69827       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69828     } catch (std::out_of_range& e) {
69829       {
69830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69831       };
69832     } catch (std::exception& e) {
69833       {
69834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69835       };
69836     } catch (Dali::DaliException e) {
69837       {
69838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69839       };
69840     } catch (...) {
69841       {
69842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69843       };
69844     }
69845   }
69846
69847   jresult = (void *)result;
69848   return jresult;
69849 }
69850
69851
69852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69853   void * jresult ;
69854   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69855   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69856
69857   arg1 = (Dali::Toolkit::Button *)jarg1;
69858   {
69859     try {
69860       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69861     } catch (std::out_of_range& e) {
69862       {
69863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69864       };
69865     } catch (std::exception& e) {
69866       {
69867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69868       };
69869     } catch (Dali::DaliException e) {
69870       {
69871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69872       };
69873     } catch (...) {
69874       {
69875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69876       };
69877     }
69878   }
69879
69880   jresult = (void *)result;
69881   return jresult;
69882 }
69883
69884
69885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69886   void * jresult ;
69887   Dali::Toolkit::CheckBoxButton *result = 0 ;
69888
69889   {
69890     try {
69891       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69892     } catch (std::out_of_range& e) {
69893       {
69894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69895       };
69896     } catch (std::exception& e) {
69897       {
69898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69899       };
69900     } catch (Dali::DaliException e) {
69901       {
69902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69903       };
69904     } catch (...) {
69905       {
69906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69907       };
69908     }
69909   }
69910
69911   jresult = (void *)result;
69912   return jresult;
69913 }
69914
69915
69916 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69917   void * jresult ;
69918   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69919   Dali::Toolkit::CheckBoxButton *result = 0 ;
69920
69921   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69922   if (!arg1) {
69923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69924     return 0;
69925   }
69926   {
69927     try {
69928       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69929     } catch (std::out_of_range& e) {
69930       {
69931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69932       };
69933     } catch (std::exception& e) {
69934       {
69935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69936       };
69937     } catch (Dali::DaliException e) {
69938       {
69939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69940       };
69941     } catch (...) {
69942       {
69943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69944       };
69945     }
69946   }
69947
69948   jresult = (void *)result;
69949   return jresult;
69950 }
69951
69952
69953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69954   void * jresult ;
69955   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69956   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69957   Dali::Toolkit::CheckBoxButton *result = 0 ;
69958
69959   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69960   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69961   if (!arg2) {
69962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69963     return 0;
69964   }
69965   {
69966     try {
69967       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69968     } catch (std::out_of_range& e) {
69969       {
69970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69971       };
69972     } catch (std::exception& e) {
69973       {
69974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69975       };
69976     } catch (Dali::DaliException e) {
69977       {
69978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69979       };
69980     } catch (...) {
69981       {
69982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69983       };
69984     }
69985   }
69986
69987   jresult = (void *)result;
69988   return jresult;
69989 }
69990
69991
69992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69993   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69994
69995   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69996   {
69997     try {
69998       delete arg1;
69999     } catch (std::out_of_range& e) {
70000       {
70001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70002       };
70003     } catch (std::exception& e) {
70004       {
70005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70006       };
70007     } catch (Dali::DaliException e) {
70008       {
70009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70010       };
70011     } catch (...) {
70012       {
70013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70014       };
70015     }
70016   }
70017
70018 }
70019
70020
70021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
70022   void * jresult ;
70023   Dali::Toolkit::CheckBoxButton result;
70024
70025   {
70026     try {
70027       result = Dali::Toolkit::CheckBoxButton::New();
70028     } catch (std::out_of_range& e) {
70029       {
70030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70031       };
70032     } catch (std::exception& e) {
70033       {
70034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70035       };
70036     } catch (Dali::DaliException e) {
70037       {
70038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70039       };
70040     } catch (...) {
70041       {
70042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70043       };
70044     }
70045   }
70046
70047   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70048   return jresult;
70049 }
70050
70051
70052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70053   void * jresult ;
70054   Dali::BaseHandle arg1 ;
70055   Dali::BaseHandle *argp1 ;
70056   Dali::Toolkit::CheckBoxButton result;
70057
70058   argp1 = (Dali::BaseHandle *)jarg1;
70059   if (!argp1) {
70060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70061     return 0;
70062   }
70063   arg1 = *argp1;
70064   {
70065     try {
70066       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70067     } catch (std::out_of_range& e) {
70068       {
70069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70070       };
70071     } catch (std::exception& e) {
70072       {
70073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70074       };
70075     } catch (Dali::DaliException e) {
70076       {
70077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70078       };
70079     } catch (...) {
70080       {
70081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70082       };
70083     }
70084   }
70085
70086   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70087   return jresult;
70088 }
70089
70090
70091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70092   int jresult ;
70093   int result;
70094
70095   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70096   jresult = (int)result;
70097   return jresult;
70098 }
70099
70100
70101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70102   int jresult ;
70103   int result;
70104
70105   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70106   jresult = (int)result;
70107   return jresult;
70108 }
70109
70110
70111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70112   int jresult ;
70113   int result;
70114
70115   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70116   jresult = (int)result;
70117   return jresult;
70118 }
70119
70120
70121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70122   int jresult ;
70123   int result;
70124
70125   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70126   jresult = (int)result;
70127   return jresult;
70128 }
70129
70130
70131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70132   int jresult ;
70133   int result;
70134
70135   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70136   jresult = (int)result;
70137   return jresult;
70138 }
70139
70140
70141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70142   void * jresult ;
70143   Dali::Toolkit::PushButton::Property *result = 0 ;
70144
70145   {
70146     try {
70147       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70148     } catch (std::out_of_range& e) {
70149       {
70150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70151       };
70152     } catch (std::exception& e) {
70153       {
70154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70155       };
70156     } catch (Dali::DaliException e) {
70157       {
70158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70159       };
70160     } catch (...) {
70161       {
70162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70163       };
70164     }
70165   }
70166
70167   jresult = (void *)result;
70168   return jresult;
70169 }
70170
70171
70172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70173   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70174
70175   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70176   {
70177     try {
70178       delete arg1;
70179     } catch (std::out_of_range& e) {
70180       {
70181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70182       };
70183     } catch (std::exception& e) {
70184       {
70185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70186       };
70187     } catch (Dali::DaliException e) {
70188       {
70189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70190       };
70191     } catch (...) {
70192       {
70193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70194       };
70195     }
70196   }
70197
70198 }
70199
70200
70201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70202   void * jresult ;
70203   Dali::Toolkit::PushButton *result = 0 ;
70204
70205   {
70206     try {
70207       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70208     } catch (std::out_of_range& e) {
70209       {
70210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70211       };
70212     } catch (std::exception& e) {
70213       {
70214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70215       };
70216     } catch (Dali::DaliException e) {
70217       {
70218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70219       };
70220     } catch (...) {
70221       {
70222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70223       };
70224     }
70225   }
70226
70227   jresult = (void *)result;
70228   return jresult;
70229 }
70230
70231
70232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70233   void * jresult ;
70234   Dali::Toolkit::PushButton *arg1 = 0 ;
70235   Dali::Toolkit::PushButton *result = 0 ;
70236
70237   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70238   if (!arg1) {
70239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70240     return 0;
70241   }
70242   {
70243     try {
70244       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70245     } catch (std::out_of_range& e) {
70246       {
70247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70248       };
70249     } catch (std::exception& e) {
70250       {
70251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70252       };
70253     } catch (Dali::DaliException e) {
70254       {
70255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70256       };
70257     } catch (...) {
70258       {
70259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70260       };
70261     }
70262   }
70263
70264   jresult = (void *)result;
70265   return jresult;
70266 }
70267
70268
70269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70270   void * jresult ;
70271   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70272   Dali::Toolkit::PushButton *arg2 = 0 ;
70273   Dali::Toolkit::PushButton *result = 0 ;
70274
70275   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70276   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70277   if (!arg2) {
70278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70279     return 0;
70280   }
70281   {
70282     try {
70283       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70284     } catch (std::out_of_range& e) {
70285       {
70286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70287       };
70288     } catch (std::exception& e) {
70289       {
70290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70291       };
70292     } catch (Dali::DaliException e) {
70293       {
70294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70295       };
70296     } catch (...) {
70297       {
70298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70299       };
70300     }
70301   }
70302
70303   jresult = (void *)result;
70304   return jresult;
70305 }
70306
70307
70308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70309   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70310
70311   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70312   {
70313     try {
70314       delete arg1;
70315     } catch (std::out_of_range& e) {
70316       {
70317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70318       };
70319     } catch (std::exception& e) {
70320       {
70321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70322       };
70323     } catch (Dali::DaliException e) {
70324       {
70325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70326       };
70327     } catch (...) {
70328       {
70329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70330       };
70331     }
70332   }
70333
70334 }
70335
70336
70337 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70338   void * jresult ;
70339   Dali::Toolkit::PushButton result;
70340
70341   {
70342     try {
70343       result = Dali::Toolkit::PushButton::New();
70344     } catch (std::out_of_range& e) {
70345       {
70346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70347       };
70348     } catch (std::exception& e) {
70349       {
70350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70351       };
70352     } catch (Dali::DaliException e) {
70353       {
70354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70355       };
70356     } catch (...) {
70357       {
70358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70359       };
70360     }
70361   }
70362
70363   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70364   return jresult;
70365 }
70366
70367
70368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70369   void * jresult ;
70370   Dali::BaseHandle arg1 ;
70371   Dali::BaseHandle *argp1 ;
70372   Dali::Toolkit::PushButton result;
70373
70374   argp1 = (Dali::BaseHandle *)jarg1;
70375   if (!argp1) {
70376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70377     return 0;
70378   }
70379   arg1 = *argp1;
70380   {
70381     try {
70382       result = Dali::Toolkit::PushButton::DownCast(arg1);
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::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70403   return jresult;
70404 }
70405
70406
70407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70408   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70409   Dali::Image arg2 ;
70410   Dali::Image *argp2 ;
70411
70412   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70413   argp2 = (Dali::Image *)jarg2;
70414   if (!argp2) {
70415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70416     return ;
70417   }
70418   arg2 = *argp2;
70419   {
70420     try {
70421       (arg1)->SetButtonImage(arg2);
70422     } catch (std::out_of_range& e) {
70423       {
70424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70425       };
70426     } catch (std::exception& e) {
70427       {
70428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70429       };
70430     } catch (Dali::DaliException e) {
70431       {
70432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70433       };
70434     } catch (...) {
70435       {
70436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70437       };
70438     }
70439   }
70440
70441 }
70442
70443
70444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70445   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70446   Dali::Actor arg2 ;
70447   Dali::Actor *argp2 ;
70448
70449   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70450   argp2 = (Dali::Actor *)jarg2;
70451   if (!argp2) {
70452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70453     return ;
70454   }
70455   arg2 = *argp2;
70456   {
70457     try {
70458       (arg1)->SetButtonImage(arg2);
70459     } catch (std::out_of_range& e) {
70460       {
70461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70462       };
70463     } catch (std::exception& e) {
70464       {
70465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70466       };
70467     } catch (Dali::DaliException e) {
70468       {
70469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70470       };
70471     } catch (...) {
70472       {
70473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70474       };
70475     }
70476   }
70477
70478 }
70479
70480
70481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70482   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70483   Dali::Actor arg2 ;
70484   Dali::Actor *argp2 ;
70485
70486   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70487   argp2 = (Dali::Actor *)jarg2;
70488   if (!argp2) {
70489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70490     return ;
70491   }
70492   arg2 = *argp2;
70493   {
70494     try {
70495       (arg1)->SetBackgroundImage(arg2);
70496     } catch (std::out_of_range& e) {
70497       {
70498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70499       };
70500     } catch (std::exception& e) {
70501       {
70502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70503       };
70504     } catch (Dali::DaliException e) {
70505       {
70506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70507       };
70508     } catch (...) {
70509       {
70510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70511       };
70512     }
70513   }
70514
70515 }
70516
70517
70518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70519   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70520   Dali::Image arg2 ;
70521   Dali::Image *argp2 ;
70522
70523   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70524   argp2 = (Dali::Image *)jarg2;
70525   if (!argp2) {
70526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70527     return ;
70528   }
70529   arg2 = *argp2;
70530   {
70531     try {
70532       (arg1)->SetSelectedImage(arg2);
70533     } catch (std::out_of_range& e) {
70534       {
70535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70536       };
70537     } catch (std::exception& e) {
70538       {
70539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70540       };
70541     } catch (Dali::DaliException e) {
70542       {
70543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70544       };
70545     } catch (...) {
70546       {
70547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70548       };
70549     }
70550   }
70551
70552 }
70553
70554
70555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70556   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70557   Dali::Actor arg2 ;
70558   Dali::Actor *argp2 ;
70559
70560   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70561   argp2 = (Dali::Actor *)jarg2;
70562   if (!argp2) {
70563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70564     return ;
70565   }
70566   arg2 = *argp2;
70567   {
70568     try {
70569       (arg1)->SetSelectedImage(arg2);
70570     } catch (std::out_of_range& e) {
70571       {
70572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70573       };
70574     } catch (std::exception& e) {
70575       {
70576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70577       };
70578     } catch (Dali::DaliException e) {
70579       {
70580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70581       };
70582     } catch (...) {
70583       {
70584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70585       };
70586     }
70587   }
70588
70589 }
70590
70591
70592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70593   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70594   Dali::Actor arg2 ;
70595   Dali::Actor *argp2 ;
70596
70597   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70598   argp2 = (Dali::Actor *)jarg2;
70599   if (!argp2) {
70600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70601     return ;
70602   }
70603   arg2 = *argp2;
70604   {
70605     try {
70606       (arg1)->SetSelectedBackgroundImage(arg2);
70607     } catch (std::out_of_range& e) {
70608       {
70609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70610       };
70611     } catch (std::exception& e) {
70612       {
70613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70614       };
70615     } catch (Dali::DaliException e) {
70616       {
70617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70618       };
70619     } catch (...) {
70620       {
70621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70622       };
70623     }
70624   }
70625
70626 }
70627
70628
70629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70630   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70631   Dali::Actor arg2 ;
70632   Dali::Actor *argp2 ;
70633
70634   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70635   argp2 = (Dali::Actor *)jarg2;
70636   if (!argp2) {
70637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70638     return ;
70639   }
70640   arg2 = *argp2;
70641   {
70642     try {
70643       (arg1)->SetDisabledBackgroundImage(arg2);
70644     } catch (std::out_of_range& e) {
70645       {
70646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70647       };
70648     } catch (std::exception& e) {
70649       {
70650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70651       };
70652     } catch (Dali::DaliException e) {
70653       {
70654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70655       };
70656     } catch (...) {
70657       {
70658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70659       };
70660     }
70661   }
70662
70663 }
70664
70665
70666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70667   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70668   Dali::Actor arg2 ;
70669   Dali::Actor *argp2 ;
70670
70671   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70672   argp2 = (Dali::Actor *)jarg2;
70673   if (!argp2) {
70674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70675     return ;
70676   }
70677   arg2 = *argp2;
70678   {
70679     try {
70680       (arg1)->SetDisabledImage(arg2);
70681     } catch (std::out_of_range& e) {
70682       {
70683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70684       };
70685     } catch (std::exception& e) {
70686       {
70687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70688       };
70689     } catch (Dali::DaliException e) {
70690       {
70691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70692       };
70693     } catch (...) {
70694       {
70695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70696       };
70697     }
70698   }
70699
70700 }
70701
70702
70703 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70704   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70705   Dali::Actor arg2 ;
70706   Dali::Actor *argp2 ;
70707
70708   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70709   argp2 = (Dali::Actor *)jarg2;
70710   if (!argp2) {
70711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70712     return ;
70713   }
70714   arg2 = *argp2;
70715   {
70716     try {
70717       (arg1)->SetDisabledSelectedImage(arg2);
70718     } catch (std::out_of_range& e) {
70719       {
70720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70721       };
70722     } catch (std::exception& e) {
70723       {
70724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70725       };
70726     } catch (Dali::DaliException e) {
70727       {
70728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70729       };
70730     } catch (...) {
70731       {
70732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70733       };
70734     }
70735   }
70736
70737 }
70738
70739
70740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70741   void * jresult ;
70742   Dali::Toolkit::RadioButton *result = 0 ;
70743
70744   {
70745     try {
70746       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70747     } catch (std::out_of_range& e) {
70748       {
70749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70750       };
70751     } catch (std::exception& e) {
70752       {
70753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70754       };
70755     } catch (Dali::DaliException e) {
70756       {
70757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70758       };
70759     } catch (...) {
70760       {
70761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70762       };
70763     }
70764   }
70765
70766   jresult = (void *)result;
70767   return jresult;
70768 }
70769
70770
70771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
70772   void * jresult ;
70773   Dali::Toolkit::RadioButton *arg1 = 0 ;
70774   Dali::Toolkit::RadioButton *result = 0 ;
70775
70776   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70777   if (!arg1) {
70778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70779     return 0;
70780   }
70781   {
70782     try {
70783       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
70784     } catch (std::out_of_range& e) {
70785       {
70786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70787       };
70788     } catch (std::exception& e) {
70789       {
70790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70791       };
70792     } catch (Dali::DaliException e) {
70793       {
70794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70795       };
70796     } catch (...) {
70797       {
70798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70799       };
70800     }
70801   }
70802
70803   jresult = (void *)result;
70804   return jresult;
70805 }
70806
70807
70808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
70809   void * jresult ;
70810   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70811   Dali::Toolkit::RadioButton *arg2 = 0 ;
70812   Dali::Toolkit::RadioButton *result = 0 ;
70813
70814   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70815   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
70816   if (!arg2) {
70817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70818     return 0;
70819   }
70820   {
70821     try {
70822       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
70823     } catch (std::out_of_range& e) {
70824       {
70825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70826       };
70827     } catch (std::exception& e) {
70828       {
70829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70830       };
70831     } catch (Dali::DaliException e) {
70832       {
70833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70834       };
70835     } catch (...) {
70836       {
70837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70838       };
70839     }
70840   }
70841
70842   jresult = (void *)result;
70843   return jresult;
70844 }
70845
70846
70847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70848   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70849
70850   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70851   {
70852     try {
70853       delete arg1;
70854     } catch (std::out_of_range& e) {
70855       {
70856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70857       };
70858     } catch (std::exception& e) {
70859       {
70860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70861       };
70862     } catch (Dali::DaliException e) {
70863       {
70864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70865       };
70866     } catch (...) {
70867       {
70868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70869       };
70870     }
70871   }
70872
70873 }
70874
70875
70876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70877   void * jresult ;
70878   Dali::Toolkit::RadioButton result;
70879
70880   {
70881     try {
70882       result = Dali::Toolkit::RadioButton::New();
70883     } catch (std::out_of_range& e) {
70884       {
70885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70886       };
70887     } catch (std::exception& e) {
70888       {
70889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70890       };
70891     } catch (Dali::DaliException e) {
70892       {
70893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70894       };
70895     } catch (...) {
70896       {
70897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70898       };
70899     }
70900   }
70901
70902   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70903   return jresult;
70904 }
70905
70906
70907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70908   void * jresult ;
70909   std::string *arg1 = 0 ;
70910   Dali::Toolkit::RadioButton result;
70911
70912   if (!jarg1) {
70913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70914     return 0;
70915   }
70916   std::string arg1_str(jarg1);
70917   arg1 = &arg1_str;
70918   {
70919     try {
70920       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
70921     } catch (std::out_of_range& e) {
70922       {
70923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70924       };
70925     } catch (std::exception& e) {
70926       {
70927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70928       };
70929     } catch (Dali::DaliException e) {
70930       {
70931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70932       };
70933     } catch (...) {
70934       {
70935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70936       };
70937     }
70938   }
70939
70940   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70941
70942   //argout typemap for const std::string&
70943
70944   return jresult;
70945 }
70946
70947
70948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70949   void * jresult ;
70950   Dali::BaseHandle arg1 ;
70951   Dali::BaseHandle *argp1 ;
70952   Dali::Toolkit::RadioButton result;
70953
70954   argp1 = (Dali::BaseHandle *)jarg1;
70955   if (!argp1) {
70956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70957     return 0;
70958   }
70959   arg1 = *argp1;
70960   {
70961     try {
70962       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70963     } catch (std::out_of_range& e) {
70964       {
70965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70966       };
70967     } catch (std::exception& e) {
70968       {
70969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70970       };
70971     } catch (Dali::DaliException e) {
70972       {
70973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70974       };
70975     } catch (...) {
70976       {
70977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70978       };
70979     }
70980   }
70981
70982   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70983   return jresult;
70984 }
70985
70986
70987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70988   int jresult ;
70989   int result;
70990
70991   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70992   jresult = (int)result;
70993   return jresult;
70994 }
70995
70996
70997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70998   int jresult ;
70999   int result;
71000
71001   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
71002   jresult = (int)result;
71003   return jresult;
71004 }
71005
71006
71007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
71008   int jresult ;
71009   int result;
71010
71011   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
71012   jresult = (int)result;
71013   return jresult;
71014 }
71015
71016
71017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
71018   int jresult ;
71019   int result;
71020
71021   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
71022   jresult = (int)result;
71023   return jresult;
71024 }
71025
71026
71027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
71028   int jresult ;
71029   int result;
71030
71031   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
71032   jresult = (int)result;
71033   return jresult;
71034 }
71035
71036
71037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71038   int jresult ;
71039   int result;
71040
71041   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71042   jresult = (int)result;
71043   return jresult;
71044 }
71045
71046
71047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71048   void * jresult ;
71049   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71050
71051   {
71052     try {
71053       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71054     } catch (std::out_of_range& e) {
71055       {
71056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71057       };
71058     } catch (std::exception& e) {
71059       {
71060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71061       };
71062     } catch (Dali::DaliException e) {
71063       {
71064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71065       };
71066     } catch (...) {
71067       {
71068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71069       };
71070     }
71071   }
71072
71073   jresult = (void *)result;
71074   return jresult;
71075 }
71076
71077
71078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71079   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71080
71081   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71082   {
71083     try {
71084       delete arg1;
71085     } catch (std::out_of_range& e) {
71086       {
71087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71088       };
71089     } catch (std::exception& e) {
71090       {
71091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71092       };
71093     } catch (Dali::DaliException e) {
71094       {
71095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71096       };
71097     } catch (...) {
71098       {
71099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71100       };
71101     }
71102   }
71103
71104 }
71105
71106
71107 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71108   int jresult ;
71109   int result;
71110
71111   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71112   jresult = (int)result;
71113   return jresult;
71114 }
71115
71116
71117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71118   int jresult ;
71119   int result;
71120
71121   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71122   jresult = (int)result;
71123   return jresult;
71124 }
71125
71126
71127 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71128   int jresult ;
71129   int result;
71130
71131   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71132   jresult = (int)result;
71133   return jresult;
71134 }
71135
71136
71137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71138   void * jresult ;
71139   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71140
71141   {
71142     try {
71143       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71144     } catch (std::out_of_range& e) {
71145       {
71146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71147       };
71148     } catch (std::exception& e) {
71149       {
71150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71151       };
71152     } catch (Dali::DaliException e) {
71153       {
71154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71155       };
71156     } catch (...) {
71157       {
71158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71159       };
71160     }
71161   }
71162
71163   jresult = (void *)result;
71164   return jresult;
71165 }
71166
71167
71168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71169   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71170
71171   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71172   {
71173     try {
71174       delete arg1;
71175     } catch (std::out_of_range& e) {
71176       {
71177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71178       };
71179     } catch (std::exception& e) {
71180       {
71181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71182       };
71183     } catch (Dali::DaliException e) {
71184       {
71185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71186       };
71187     } catch (...) {
71188       {
71189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71190       };
71191     }
71192   }
71193
71194 }
71195
71196
71197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71198   void * jresult ;
71199   Dali::Toolkit::FlexContainer *result = 0 ;
71200
71201   {
71202     try {
71203       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71204     } catch (std::out_of_range& e) {
71205       {
71206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71207       };
71208     } catch (std::exception& e) {
71209       {
71210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71211       };
71212     } catch (Dali::DaliException e) {
71213       {
71214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71215       };
71216     } catch (...) {
71217       {
71218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71219       };
71220     }
71221   }
71222
71223   jresult = (void *)result;
71224   return jresult;
71225 }
71226
71227
71228 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71229   void * jresult ;
71230   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71231   Dali::Toolkit::FlexContainer *result = 0 ;
71232
71233   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71234   if (!arg1) {
71235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71236     return 0;
71237   }
71238   {
71239     try {
71240       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71241     } catch (std::out_of_range& e) {
71242       {
71243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71244       };
71245     } catch (std::exception& e) {
71246       {
71247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71248       };
71249     } catch (Dali::DaliException e) {
71250       {
71251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71252       };
71253     } catch (...) {
71254       {
71255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71256       };
71257     }
71258   }
71259
71260   jresult = (void *)result;
71261   return jresult;
71262 }
71263
71264
71265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71266   void * jresult ;
71267   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71268   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71269   Dali::Toolkit::FlexContainer *result = 0 ;
71270
71271   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71272   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71273   if (!arg2) {
71274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71275     return 0;
71276   }
71277   {
71278     try {
71279       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71280     } catch (std::out_of_range& e) {
71281       {
71282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71283       };
71284     } catch (std::exception& e) {
71285       {
71286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71287       };
71288     } catch (Dali::DaliException e) {
71289       {
71290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71291       };
71292     } catch (...) {
71293       {
71294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71295       };
71296     }
71297   }
71298
71299   jresult = (void *)result;
71300   return jresult;
71301 }
71302
71303
71304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71305   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71306
71307   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71308   {
71309     try {
71310       delete arg1;
71311     } catch (std::out_of_range& e) {
71312       {
71313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71314       };
71315     } catch (std::exception& e) {
71316       {
71317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71318       };
71319     } catch (Dali::DaliException e) {
71320       {
71321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71322       };
71323     } catch (...) {
71324       {
71325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71326       };
71327     }
71328   }
71329
71330 }
71331
71332
71333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71334   void * jresult ;
71335   Dali::Toolkit::FlexContainer result;
71336
71337   {
71338     try {
71339       result = Dali::Toolkit::FlexContainer::New();
71340     } catch (std::out_of_range& e) {
71341       {
71342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71343       };
71344     } catch (std::exception& e) {
71345       {
71346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71347       };
71348     } catch (Dali::DaliException e) {
71349       {
71350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71351       };
71352     } catch (...) {
71353       {
71354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71355       };
71356     }
71357   }
71358
71359   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71360   return jresult;
71361 }
71362
71363
71364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71365   void * jresult ;
71366   Dali::BaseHandle arg1 ;
71367   Dali::BaseHandle *argp1 ;
71368   Dali::Toolkit::FlexContainer result;
71369
71370   argp1 = (Dali::BaseHandle *)jarg1;
71371   if (!argp1) {
71372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71373     return 0;
71374   }
71375   arg1 = *argp1;
71376   {
71377     try {
71378       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71379     } catch (std::out_of_range& e) {
71380       {
71381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71382       };
71383     } catch (std::exception& e) {
71384       {
71385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71386       };
71387     } catch (Dali::DaliException e) {
71388       {
71389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71390       };
71391     } catch (...) {
71392       {
71393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71394       };
71395     }
71396   }
71397
71398   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71399   return jresult;
71400 }
71401
71402
71403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71404   int jresult ;
71405   int result;
71406
71407   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71408   jresult = (int)result;
71409   return jresult;
71410 }
71411
71412
71413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71414   int jresult ;
71415   int result;
71416
71417   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71418   jresult = (int)result;
71419   return jresult;
71420 }
71421
71422
71423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71424   int jresult ;
71425   int result;
71426
71427   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71428   jresult = (int)result;
71429   return jresult;
71430 }
71431
71432
71433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71434   int jresult ;
71435   int result;
71436
71437   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71438   jresult = (int)result;
71439   return jresult;
71440 }
71441
71442
71443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71444   void * jresult ;
71445   Dali::Toolkit::ImageView::Property *result = 0 ;
71446
71447   {
71448     try {
71449       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71450     } catch (std::out_of_range& e) {
71451       {
71452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71453       };
71454     } catch (std::exception& e) {
71455       {
71456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71457       };
71458     } catch (Dali::DaliException e) {
71459       {
71460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71461       };
71462     } catch (...) {
71463       {
71464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71465       };
71466     }
71467   }
71468
71469   jresult = (void *)result;
71470   return jresult;
71471 }
71472
71473
71474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71475   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71476
71477   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71478   {
71479     try {
71480       delete arg1;
71481     } catch (std::out_of_range& e) {
71482       {
71483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71484       };
71485     } catch (std::exception& e) {
71486       {
71487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71488       };
71489     } catch (Dali::DaliException e) {
71490       {
71491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71492       };
71493     } catch (...) {
71494       {
71495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71496       };
71497     }
71498   }
71499
71500 }
71501
71502
71503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71504   void * jresult ;
71505   Dali::Toolkit::ImageView *result = 0 ;
71506
71507   {
71508     try {
71509       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71510     } catch (std::out_of_range& e) {
71511       {
71512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71513       };
71514     } catch (std::exception& e) {
71515       {
71516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71517       };
71518     } catch (Dali::DaliException e) {
71519       {
71520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71521       };
71522     } catch (...) {
71523       {
71524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71525       };
71526     }
71527   }
71528
71529   jresult = (void *)result;
71530   return jresult;
71531 }
71532
71533
71534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71535   void * jresult ;
71536   Dali::Toolkit::ImageView result;
71537
71538   {
71539     try {
71540       result = Dali::Toolkit::ImageView::New();
71541     } catch (std::out_of_range& e) {
71542       {
71543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71544       };
71545     } catch (std::exception& e) {
71546       {
71547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71548       };
71549     } catch (Dali::DaliException e) {
71550       {
71551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71552       };
71553     } catch (...) {
71554       {
71555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71556       };
71557     }
71558   }
71559
71560   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71561   return jresult;
71562 }
71563
71564
71565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71566   void * jresult ;
71567   Dali::Image arg1 ;
71568   Dali::Image *argp1 ;
71569   Dali::Toolkit::ImageView result;
71570
71571   argp1 = (Dali::Image *)jarg1;
71572   if (!argp1) {
71573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71574     return 0;
71575   }
71576   arg1 = *argp1;
71577   {
71578     try {
71579       result = Dali::Toolkit::ImageView::New(arg1);
71580     } catch (std::out_of_range& e) {
71581       {
71582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71583       };
71584     } catch (std::exception& e) {
71585       {
71586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71587       };
71588     } catch (Dali::DaliException e) {
71589       {
71590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71591       };
71592     } catch (...) {
71593       {
71594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71595       };
71596     }
71597   }
71598
71599   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71600   return jresult;
71601 }
71602
71603
71604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71605   void * jresult ;
71606   std::string *arg1 = 0 ;
71607   Dali::Toolkit::ImageView result;
71608
71609   if (!jarg1) {
71610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71611     return 0;
71612   }
71613   std::string arg1_str(jarg1);
71614   arg1 = &arg1_str;
71615   {
71616     try {
71617       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
71618     } catch (std::out_of_range& e) {
71619       {
71620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71621       };
71622     } catch (std::exception& e) {
71623       {
71624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71625       };
71626     } catch (Dali::DaliException e) {
71627       {
71628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71629       };
71630     } catch (...) {
71631       {
71632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71633       };
71634     }
71635   }
71636
71637   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71638
71639   //argout typemap for const std::string&
71640
71641   return jresult;
71642 }
71643
71644
71645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71646   void * jresult ;
71647   std::string *arg1 = 0 ;
71648   Dali::ImageDimensions arg2 ;
71649   Dali::ImageDimensions *argp2 ;
71650   Dali::Toolkit::ImageView result;
71651
71652   if (!jarg1) {
71653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71654     return 0;
71655   }
71656   std::string arg1_str(jarg1);
71657   arg1 = &arg1_str;
71658   argp2 = (Dali::ImageDimensions *)jarg2;
71659   if (!argp2) {
71660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71661     return 0;
71662   }
71663   arg2 = *argp2;
71664   {
71665     try {
71666       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71667     } catch (std::out_of_range& e) {
71668       {
71669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71670       };
71671     } catch (std::exception& e) {
71672       {
71673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71674       };
71675     } catch (Dali::DaliException e) {
71676       {
71677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71678       };
71679     } catch (...) {
71680       {
71681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71682       };
71683     }
71684   }
71685
71686   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71687
71688   //argout typemap for const std::string&
71689
71690   return jresult;
71691 }
71692
71693
71694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71695   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71696
71697   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71698   {
71699     try {
71700       delete arg1;
71701     } catch (std::out_of_range& e) {
71702       {
71703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71704       };
71705     } catch (std::exception& e) {
71706       {
71707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71708       };
71709     } catch (Dali::DaliException e) {
71710       {
71711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71712       };
71713     } catch (...) {
71714       {
71715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71716       };
71717     }
71718   }
71719
71720 }
71721
71722
71723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71724   void * jresult ;
71725   Dali::Toolkit::ImageView *arg1 = 0 ;
71726   Dali::Toolkit::ImageView *result = 0 ;
71727
71728   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71729   if (!arg1) {
71730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71731     return 0;
71732   }
71733   {
71734     try {
71735       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71736     } catch (std::out_of_range& e) {
71737       {
71738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71739       };
71740     } catch (std::exception& e) {
71741       {
71742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71743       };
71744     } catch (Dali::DaliException e) {
71745       {
71746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71747       };
71748     } catch (...) {
71749       {
71750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71751       };
71752     }
71753   }
71754
71755   jresult = (void *)result;
71756   return jresult;
71757 }
71758
71759
71760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
71761   void * jresult ;
71762   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71763   Dali::Toolkit::ImageView *arg2 = 0 ;
71764   Dali::Toolkit::ImageView *result = 0 ;
71765
71766   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71767   arg2 = (Dali::Toolkit::ImageView *)jarg2;
71768   if (!arg2) {
71769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71770     return 0;
71771   }
71772   {
71773     try {
71774       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
71775     } catch (std::out_of_range& e) {
71776       {
71777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71778       };
71779     } catch (std::exception& e) {
71780       {
71781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71782       };
71783     } catch (Dali::DaliException e) {
71784       {
71785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71786       };
71787     } catch (...) {
71788       {
71789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71790       };
71791     }
71792   }
71793
71794   jresult = (void *)result;
71795   return jresult;
71796 }
71797
71798
71799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
71800   void * jresult ;
71801   Dali::BaseHandle arg1 ;
71802   Dali::BaseHandle *argp1 ;
71803   Dali::Toolkit::ImageView result;
71804
71805   argp1 = (Dali::BaseHandle *)jarg1;
71806   if (!argp1) {
71807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71808     return 0;
71809   }
71810   arg1 = *argp1;
71811   {
71812     try {
71813       result = Dali::Toolkit::ImageView::DownCast(arg1);
71814     } catch (std::out_of_range& e) {
71815       {
71816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71817       };
71818     } catch (std::exception& e) {
71819       {
71820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71821       };
71822     } catch (Dali::DaliException e) {
71823       {
71824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71825       };
71826     } catch (...) {
71827       {
71828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71829       };
71830     }
71831   }
71832
71833   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71834   return jresult;
71835 }
71836
71837
71838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
71839   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71840   Dali::Image arg2 ;
71841   Dali::Image *argp2 ;
71842
71843   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71844   argp2 = (Dali::Image *)jarg2;
71845   if (!argp2) {
71846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71847     return ;
71848   }
71849   arg2 = *argp2;
71850   {
71851     try {
71852       (arg1)->SetImage(arg2);
71853     } catch (std::out_of_range& e) {
71854       {
71855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71856       };
71857     } catch (std::exception& e) {
71858       {
71859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71860       };
71861     } catch (Dali::DaliException e) {
71862       {
71863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71864       };
71865     } catch (...) {
71866       {
71867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71868       };
71869     }
71870   }
71871
71872 }
71873
71874
71875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71876   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71877   std::string *arg2 = 0 ;
71878
71879   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71880   if (!jarg2) {
71881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71882     return ;
71883   }
71884   std::string arg2_str(jarg2);
71885   arg2 = &arg2_str;
71886   {
71887     try {
71888       (arg1)->SetImage((std::string const &)*arg2);
71889     } catch (std::out_of_range& e) {
71890       {
71891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71892       };
71893     } catch (std::exception& e) {
71894       {
71895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71896       };
71897     } catch (Dali::DaliException e) {
71898       {
71899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71900       };
71901     } catch (...) {
71902       {
71903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71904       };
71905     }
71906   }
71907
71908
71909   //argout typemap for const std::string&
71910
71911 }
71912
71913
71914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71915   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71916   std::string *arg2 = 0 ;
71917   Dali::ImageDimensions arg3 ;
71918   Dali::ImageDimensions *argp3 ;
71919
71920   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71921   if (!jarg2) {
71922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71923     return ;
71924   }
71925   std::string arg2_str(jarg2);
71926   arg2 = &arg2_str;
71927   argp3 = (Dali::ImageDimensions *)jarg3;
71928   if (!argp3) {
71929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71930     return ;
71931   }
71932   arg3 = *argp3;
71933   {
71934     try {
71935       (arg1)->SetImage((std::string const &)*arg2,arg3);
71936     } catch (std::out_of_range& e) {
71937       {
71938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71939       };
71940     } catch (std::exception& e) {
71941       {
71942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71943       };
71944     } catch (Dali::DaliException e) {
71945       {
71946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71947       };
71948     } catch (...) {
71949       {
71950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71951       };
71952     }
71953   }
71954
71955
71956   //argout typemap for const std::string&
71957
71958 }
71959
71960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71961   void * jresult ;
71962   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71963   Dali::Image result;
71964
71965   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71966   {
71967     try {
71968       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71969     } catch (std::out_of_range& e) {
71970       {
71971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71972       };
71973     } catch (std::exception& e) {
71974       {
71975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71976       };
71977     } catch (Dali::DaliException e) {
71978       {
71979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71980       };
71981     } catch (...) {
71982       {
71983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71984       };
71985     }
71986   }
71987
71988   jresult = new Dali::Image((const Dali::Image &)result);
71989   return jresult;
71990 }
71991
71992
71993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71994   int jresult ;
71995   int result;
71996
71997   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71998   jresult = (int)result;
71999   return jresult;
72000 }
72001
72002
72003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
72004   int jresult ;
72005   int result;
72006
72007   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
72008   jresult = (int)result;
72009   return jresult;
72010 }
72011
72012
72013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
72014   int jresult ;
72015   int result;
72016
72017   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
72018   jresult = (int)result;
72019   return jresult;
72020 }
72021
72022
72023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
72024   int jresult ;
72025   int result;
72026
72027   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
72028   jresult = (int)result;
72029   return jresult;
72030 }
72031
72032
72033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
72034   int jresult ;
72035   int result;
72036
72037   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72038   jresult = (int)result;
72039   return jresult;
72040 }
72041
72042
72043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72044   int jresult ;
72045   int result;
72046
72047   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72048   jresult = (int)result;
72049   return jresult;
72050 }
72051
72052
72053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72054   int jresult ;
72055   int result;
72056
72057   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72058   jresult = (int)result;
72059   return jresult;
72060 }
72061
72062
72063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72064   int jresult ;
72065   int result;
72066
72067   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72068   jresult = (int)result;
72069   return jresult;
72070 }
72071
72072
72073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72074   void * jresult ;
72075   Dali::Toolkit::Model3dView::Property *result = 0 ;
72076
72077   {
72078     try {
72079       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72080     } catch (std::out_of_range& e) {
72081       {
72082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72083       };
72084     } catch (std::exception& e) {
72085       {
72086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72087       };
72088     } catch (Dali::DaliException e) {
72089       {
72090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72091       };
72092     } catch (...) {
72093       {
72094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72095       };
72096     }
72097   }
72098
72099   jresult = (void *)result;
72100   return jresult;
72101 }
72102
72103
72104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72105   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72106
72107   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72108   {
72109     try {
72110       delete arg1;
72111     } catch (std::out_of_range& e) {
72112       {
72113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72114       };
72115     } catch (std::exception& e) {
72116       {
72117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72118       };
72119     } catch (Dali::DaliException e) {
72120       {
72121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72122       };
72123     } catch (...) {
72124       {
72125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72126       };
72127     }
72128   }
72129
72130 }
72131
72132
72133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72134   void * jresult ;
72135   Dali::Toolkit::Model3dView result;
72136
72137   {
72138     try {
72139       result = Dali::Toolkit::Model3dView::New();
72140     } catch (std::out_of_range& e) {
72141       {
72142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72143       };
72144     } catch (std::exception& e) {
72145       {
72146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72147       };
72148     } catch (Dali::DaliException e) {
72149       {
72150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72151       };
72152     } catch (...) {
72153       {
72154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72155       };
72156     }
72157   }
72158
72159   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72160   return jresult;
72161 }
72162
72163
72164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72165   void * jresult ;
72166   std::string *arg1 = 0 ;
72167   std::string *arg2 = 0 ;
72168   std::string *arg3 = 0 ;
72169   Dali::Toolkit::Model3dView result;
72170
72171   if (!jarg1) {
72172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72173     return 0;
72174   }
72175   std::string arg1_str(jarg1);
72176   arg1 = &arg1_str;
72177   if (!jarg2) {
72178     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72179     return 0;
72180   }
72181   std::string arg2_str(jarg2);
72182   arg2 = &arg2_str;
72183   if (!jarg3) {
72184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72185     return 0;
72186   }
72187   std::string arg3_str(jarg3);
72188   arg3 = &arg3_str;
72189   {
72190     try {
72191       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72192     } catch (std::out_of_range& e) {
72193       {
72194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72195       };
72196     } catch (std::exception& e) {
72197       {
72198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72199       };
72200     } catch (Dali::DaliException e) {
72201       {
72202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72203       };
72204     } catch (...) {
72205       {
72206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72207       };
72208     }
72209   }
72210
72211   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72212
72213   //argout typemap for const std::string&
72214
72215
72216   //argout typemap for const std::string&
72217
72218
72219   //argout typemap for const std::string&
72220
72221   return jresult;
72222 }
72223
72224
72225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72226   void * jresult ;
72227   Dali::Toolkit::Model3dView *result = 0 ;
72228
72229   {
72230     try {
72231       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72232     } catch (std::out_of_range& e) {
72233       {
72234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72235       };
72236     } catch (std::exception& e) {
72237       {
72238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72239       };
72240     } catch (Dali::DaliException e) {
72241       {
72242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72243       };
72244     } catch (...) {
72245       {
72246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72247       };
72248     }
72249   }
72250
72251   jresult = (void *)result;
72252   return jresult;
72253 }
72254
72255
72256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72257   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72258
72259   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72260   {
72261     try {
72262       delete arg1;
72263     } catch (std::out_of_range& e) {
72264       {
72265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72266       };
72267     } catch (std::exception& e) {
72268       {
72269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72270       };
72271     } catch (Dali::DaliException e) {
72272       {
72273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72274       };
72275     } catch (...) {
72276       {
72277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72278       };
72279     }
72280   }
72281
72282 }
72283
72284
72285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72286   void * jresult ;
72287   Dali::Toolkit::Model3dView *arg1 = 0 ;
72288   Dali::Toolkit::Model3dView *result = 0 ;
72289
72290   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72291   if (!arg1) {
72292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72293     return 0;
72294   }
72295   {
72296     try {
72297       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72298     } catch (std::out_of_range& e) {
72299       {
72300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72301       };
72302     } catch (std::exception& e) {
72303       {
72304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72305       };
72306     } catch (Dali::DaliException e) {
72307       {
72308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72309       };
72310     } catch (...) {
72311       {
72312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72313       };
72314     }
72315   }
72316
72317   jresult = (void *)result;
72318   return jresult;
72319 }
72320
72321
72322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72323   void * jresult ;
72324   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72325   Dali::Toolkit::Model3dView *arg2 = 0 ;
72326   Dali::Toolkit::Model3dView *result = 0 ;
72327
72328   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72329   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72330   if (!arg2) {
72331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72332     return 0;
72333   }
72334   {
72335     try {
72336       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72337     } catch (std::out_of_range& e) {
72338       {
72339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72340       };
72341     } catch (std::exception& e) {
72342       {
72343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72344       };
72345     } catch (Dali::DaliException e) {
72346       {
72347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72348       };
72349     } catch (...) {
72350       {
72351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72352       };
72353     }
72354   }
72355
72356   jresult = (void *)result;
72357   return jresult;
72358 }
72359
72360
72361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72362   void * jresult ;
72363   Dali::BaseHandle arg1 ;
72364   Dali::BaseHandle *argp1 ;
72365   Dali::Toolkit::Model3dView result;
72366
72367   argp1 = (Dali::BaseHandle *)jarg1;
72368   if (!argp1) {
72369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72370     return 0;
72371   }
72372   arg1 = *argp1;
72373   {
72374     try {
72375       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72376     } catch (std::out_of_range& e) {
72377       {
72378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72379       };
72380     } catch (std::exception& e) {
72381       {
72382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72383       };
72384     } catch (Dali::DaliException e) {
72385       {
72386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72387       };
72388     } catch (...) {
72389       {
72390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72391       };
72392     }
72393   }
72394
72395   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72396   return jresult;
72397 }
72398
72399
72400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72401   int jresult ;
72402   int result;
72403
72404   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72405   jresult = (int)result;
72406   return jresult;
72407 }
72408
72409
72410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72411   int jresult ;
72412   int result;
72413
72414   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72415   jresult = (int)result;
72416   return jresult;
72417 }
72418
72419
72420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72421   int jresult ;
72422   int result;
72423
72424   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72425   jresult = (int)result;
72426   return jresult;
72427 }
72428
72429
72430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72431   int jresult ;
72432   int result;
72433
72434   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72435   jresult = (int)result;
72436   return jresult;
72437 }
72438
72439
72440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72441   int jresult ;
72442   int result;
72443
72444   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72445   jresult = (int)result;
72446   return jresult;
72447 }
72448
72449
72450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72451   int jresult ;
72452   int result;
72453
72454   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72455   jresult = (int)result;
72456   return jresult;
72457 }
72458
72459
72460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72461   int jresult ;
72462   int result;
72463
72464   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72465   jresult = (int)result;
72466   return jresult;
72467 }
72468
72469
72470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72471   int jresult ;
72472   int result;
72473
72474   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72475   jresult = (int)result;
72476   return jresult;
72477 }
72478
72479
72480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72481   int jresult ;
72482   int result;
72483
72484   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72485   jresult = (int)result;
72486   return jresult;
72487 }
72488
72489
72490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72491   void * jresult ;
72492   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72493
72494   {
72495     try {
72496       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72497     } catch (std::out_of_range& e) {
72498       {
72499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72500       };
72501     } catch (std::exception& e) {
72502       {
72503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72504       };
72505     } catch (Dali::DaliException e) {
72506       {
72507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72508       };
72509     } catch (...) {
72510       {
72511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72512       };
72513     }
72514   }
72515
72516   jresult = (void *)result;
72517   return jresult;
72518 }
72519
72520
72521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72522   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72523
72524   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72525   {
72526     try {
72527       delete arg1;
72528     } catch (std::out_of_range& e) {
72529       {
72530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72531       };
72532     } catch (std::exception& e) {
72533       {
72534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72535       };
72536     } catch (Dali::DaliException e) {
72537       {
72538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72539       };
72540     } catch (...) {
72541       {
72542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72543       };
72544     }
72545   }
72546
72547 }
72548
72549
72550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72551   void * jresult ;
72552   Dali::Toolkit::ScrollBar *result = 0 ;
72553
72554   {
72555     try {
72556       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72557     } catch (std::out_of_range& e) {
72558       {
72559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72560       };
72561     } catch (std::exception& e) {
72562       {
72563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72564       };
72565     } catch (Dali::DaliException e) {
72566       {
72567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72568       };
72569     } catch (...) {
72570       {
72571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72572       };
72573     }
72574   }
72575
72576   jresult = (void *)result;
72577   return jresult;
72578 }
72579
72580
72581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72582   void * jresult ;
72583   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72584   Dali::Toolkit::ScrollBar *result = 0 ;
72585
72586   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72587   if (!arg1) {
72588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72589     return 0;
72590   }
72591   {
72592     try {
72593       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72594     } catch (std::out_of_range& e) {
72595       {
72596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72597       };
72598     } catch (std::exception& e) {
72599       {
72600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72601       };
72602     } catch (Dali::DaliException e) {
72603       {
72604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72605       };
72606     } catch (...) {
72607       {
72608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72609       };
72610     }
72611   }
72612
72613   jresult = (void *)result;
72614   return jresult;
72615 }
72616
72617
72618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72619   void * jresult ;
72620   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72621   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72622   Dali::Toolkit::ScrollBar *result = 0 ;
72623
72624   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72625   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72626   if (!arg2) {
72627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72628     return 0;
72629   }
72630   {
72631     try {
72632       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72633     } catch (std::out_of_range& e) {
72634       {
72635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72636       };
72637     } catch (std::exception& e) {
72638       {
72639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72640       };
72641     } catch (Dali::DaliException e) {
72642       {
72643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72644       };
72645     } catch (...) {
72646       {
72647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72648       };
72649     }
72650   }
72651
72652   jresult = (void *)result;
72653   return jresult;
72654 }
72655
72656
72657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72658   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72659
72660   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72661   {
72662     try {
72663       delete arg1;
72664     } catch (std::out_of_range& e) {
72665       {
72666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72667       };
72668     } catch (std::exception& e) {
72669       {
72670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72671       };
72672     } catch (Dali::DaliException e) {
72673       {
72674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72675       };
72676     } catch (...) {
72677       {
72678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72679       };
72680     }
72681   }
72682
72683 }
72684
72685
72686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72687   void * jresult ;
72688   Dali::Toolkit::ScrollBar::Direction arg1 ;
72689   Dali::Toolkit::ScrollBar result;
72690
72691   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72692   {
72693     try {
72694       result = Dali::Toolkit::ScrollBar::New(arg1);
72695     } catch (std::out_of_range& e) {
72696       {
72697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72698       };
72699     } catch (std::exception& e) {
72700       {
72701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72702       };
72703     } catch (Dali::DaliException e) {
72704       {
72705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72706       };
72707     } catch (...) {
72708       {
72709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72710       };
72711     }
72712   }
72713
72714   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72715   return jresult;
72716 }
72717
72718
72719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72720   void * jresult ;
72721   Dali::Toolkit::ScrollBar result;
72722
72723   {
72724     try {
72725       result = Dali::Toolkit::ScrollBar::New();
72726     } catch (std::out_of_range& e) {
72727       {
72728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72729       };
72730     } catch (std::exception& e) {
72731       {
72732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72733       };
72734     } catch (Dali::DaliException e) {
72735       {
72736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72737       };
72738     } catch (...) {
72739       {
72740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72741       };
72742     }
72743   }
72744
72745   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72746   return jresult;
72747 }
72748
72749
72750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72751   void * jresult ;
72752   Dali::BaseHandle arg1 ;
72753   Dali::BaseHandle *argp1 ;
72754   Dali::Toolkit::ScrollBar result;
72755
72756   argp1 = (Dali::BaseHandle *)jarg1;
72757   if (!argp1) {
72758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72759     return 0;
72760   }
72761   arg1 = *argp1;
72762   {
72763     try {
72764       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
72765     } catch (std::out_of_range& e) {
72766       {
72767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72768       };
72769     } catch (std::exception& e) {
72770       {
72771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72772       };
72773     } catch (Dali::DaliException e) {
72774       {
72775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72776       };
72777     } catch (...) {
72778       {
72779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72780       };
72781     }
72782   }
72783
72784   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72785   return jresult;
72786 }
72787
72788
72789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
72790   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72791   Dali::Handle arg2 ;
72792   Dali::Property::Index arg3 ;
72793   Dali::Property::Index arg4 ;
72794   Dali::Property::Index arg5 ;
72795   Dali::Property::Index arg6 ;
72796   Dali::Handle *argp2 ;
72797
72798   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72799   argp2 = (Dali::Handle *)jarg2;
72800   if (!argp2) {
72801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
72802     return ;
72803   }
72804   arg2 = *argp2;
72805   arg3 = (Dali::Property::Index)jarg3;
72806   arg4 = (Dali::Property::Index)jarg4;
72807   arg5 = (Dali::Property::Index)jarg5;
72808   arg6 = (Dali::Property::Index)jarg6;
72809   {
72810     try {
72811       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
72812     } catch (std::out_of_range& e) {
72813       {
72814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72815       };
72816     } catch (std::exception& e) {
72817       {
72818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72819       };
72820     } catch (Dali::DaliException e) {
72821       {
72822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72823       };
72824     } catch (...) {
72825       {
72826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72827       };
72828     }
72829   }
72830
72831 }
72832
72833
72834 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
72835   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72836   Dali::Actor arg2 ;
72837   Dali::Actor *argp2 ;
72838
72839   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72840   argp2 = (Dali::Actor *)jarg2;
72841   if (!argp2) {
72842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72843     return ;
72844   }
72845   arg2 = *argp2;
72846   {
72847     try {
72848       (arg1)->SetScrollIndicator(arg2);
72849     } catch (std::out_of_range& e) {
72850       {
72851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72852       };
72853     } catch (std::exception& e) {
72854       {
72855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72856       };
72857     } catch (Dali::DaliException e) {
72858       {
72859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72860       };
72861     } catch (...) {
72862       {
72863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72864       };
72865     }
72866   }
72867
72868 }
72869
72870
72871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72872   void * jresult ;
72873   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72874   Dali::Actor result;
72875
72876   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72877   {
72878     try {
72879       result = (arg1)->GetScrollIndicator();
72880     } catch (std::out_of_range& e) {
72881       {
72882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72883       };
72884     } catch (std::exception& e) {
72885       {
72886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72887       };
72888     } catch (Dali::DaliException e) {
72889       {
72890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72891       };
72892     } catch (...) {
72893       {
72894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72895       };
72896     }
72897   }
72898
72899   jresult = new Dali::Actor((const Dali::Actor &)result);
72900   return jresult;
72901 }
72902
72903
72904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72905   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72906   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72907
72908   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72909   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72910   if (!arg2) {
72911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72912     return ;
72913   }
72914   {
72915     try {
72916       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
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_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72940   void * jresult ;
72941   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72942
72943   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72944   {
72945     try {
72946       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()));
72947     } catch (std::out_of_range& e) {
72948       {
72949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72950       };
72951     } catch (std::exception& e) {
72952       {
72953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72954       };
72955     } catch (...) {
72956       {
72957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72958       };
72959     }
72960   }
72961   return jresult;
72962 }
72963
72964
72965 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72966   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72967   Dali::Toolkit::ScrollBar::Direction arg2 ;
72968
72969   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72970   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72971   {
72972     try {
72973       (arg1)->SetScrollDirection(arg2);
72974     } catch (std::out_of_range& e) {
72975       {
72976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72977       };
72978     } catch (std::exception& e) {
72979       {
72980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72981       };
72982     } catch (Dali::DaliException e) {
72983       {
72984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72985       };
72986     } catch (...) {
72987       {
72988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72989       };
72990     }
72991   }
72992
72993 }
72994
72995
72996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72997   int jresult ;
72998   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72999   Dali::Toolkit::ScrollBar::Direction result;
73000
73001   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73002   {
73003     try {
73004       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
73005     } catch (std::out_of_range& e) {
73006       {
73007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73008       };
73009     } catch (std::exception& e) {
73010       {
73011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73012       };
73013     } catch (Dali::DaliException e) {
73014       {
73015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73016       };
73017     } catch (...) {
73018       {
73019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73020       };
73021     }
73022   }
73023
73024   jresult = (int)result;
73025   return jresult;
73026 }
73027
73028
73029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
73030   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73031   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
73032
73033   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73034   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
73035   {
73036     try {
73037       (arg1)->SetIndicatorHeightPolicy(arg2);
73038     } catch (std::out_of_range& e) {
73039       {
73040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73041       };
73042     } catch (std::exception& e) {
73043       {
73044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73045       };
73046     } catch (Dali::DaliException e) {
73047       {
73048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73049       };
73050     } catch (...) {
73051       {
73052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73053       };
73054     }
73055   }
73056
73057 }
73058
73059
73060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73061   int jresult ;
73062   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73063   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73064
73065   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73066   {
73067     try {
73068       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73069     } catch (std::out_of_range& e) {
73070       {
73071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73072       };
73073     } catch (std::exception& e) {
73074       {
73075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73076       };
73077     } catch (Dali::DaliException e) {
73078       {
73079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73080       };
73081     } catch (...) {
73082       {
73083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73084       };
73085     }
73086   }
73087
73088   jresult = (int)result;
73089   return jresult;
73090 }
73091
73092
73093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73094   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73095   float arg2 ;
73096
73097   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73098   arg2 = (float)jarg2;
73099   {
73100     try {
73101       (arg1)->SetIndicatorFixedHeight(arg2);
73102     } catch (std::out_of_range& e) {
73103       {
73104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73105       };
73106     } catch (std::exception& e) {
73107       {
73108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73109       };
73110     } catch (Dali::DaliException e) {
73111       {
73112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73113       };
73114     } catch (...) {
73115       {
73116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73117       };
73118     }
73119   }
73120
73121 }
73122
73123
73124 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73125   float jresult ;
73126   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73127   float result;
73128
73129   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73130   {
73131     try {
73132       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73133     } catch (std::out_of_range& e) {
73134       {
73135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73136       };
73137     } catch (std::exception& e) {
73138       {
73139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73140       };
73141     } catch (Dali::DaliException e) {
73142       {
73143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73144       };
73145     } catch (...) {
73146       {
73147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73148       };
73149     }
73150   }
73151
73152   jresult = result;
73153   return jresult;
73154 }
73155
73156
73157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73158   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73159   float arg2 ;
73160
73161   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73162   arg2 = (float)jarg2;
73163   {
73164     try {
73165       (arg1)->SetIndicatorShowDuration(arg2);
73166     } catch (std::out_of_range& e) {
73167       {
73168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73169       };
73170     } catch (std::exception& e) {
73171       {
73172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73173       };
73174     } catch (Dali::DaliException e) {
73175       {
73176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73177       };
73178     } catch (...) {
73179       {
73180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73181       };
73182     }
73183   }
73184
73185 }
73186
73187
73188 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73189   float jresult ;
73190   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73191   float result;
73192
73193   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73194   {
73195     try {
73196       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73197     } catch (std::out_of_range& e) {
73198       {
73199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73200       };
73201     } catch (std::exception& e) {
73202       {
73203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73204       };
73205     } catch (Dali::DaliException e) {
73206       {
73207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73208       };
73209     } catch (...) {
73210       {
73211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73212       };
73213     }
73214   }
73215
73216   jresult = result;
73217   return jresult;
73218 }
73219
73220
73221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73222   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73223   float arg2 ;
73224
73225   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73226   arg2 = (float)jarg2;
73227   {
73228     try {
73229       (arg1)->SetIndicatorHideDuration(arg2);
73230     } catch (std::out_of_range& e) {
73231       {
73232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73233       };
73234     } catch (std::exception& e) {
73235       {
73236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73237       };
73238     } catch (Dali::DaliException e) {
73239       {
73240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73241       };
73242     } catch (...) {
73243       {
73244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73245       };
73246     }
73247   }
73248
73249 }
73250
73251
73252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73253   float jresult ;
73254   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73255   float result;
73256
73257   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73258   {
73259     try {
73260       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73261     } catch (std::out_of_range& e) {
73262       {
73263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73264       };
73265     } catch (std::exception& e) {
73266       {
73267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73268       };
73269     } catch (Dali::DaliException e) {
73270       {
73271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73272       };
73273     } catch (...) {
73274       {
73275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73276       };
73277     }
73278   }
73279
73280   jresult = result;
73281   return jresult;
73282 }
73283
73284
73285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73286   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73287
73288   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73289   {
73290     try {
73291       (arg1)->ShowIndicator();
73292     } catch (std::out_of_range& e) {
73293       {
73294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73295       };
73296     } catch (std::exception& e) {
73297       {
73298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73299       };
73300     } catch (Dali::DaliException e) {
73301       {
73302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73303       };
73304     } catch (...) {
73305       {
73306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73307       };
73308     }
73309   }
73310
73311 }
73312
73313
73314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73315   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73316
73317   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73318   {
73319     try {
73320       (arg1)->HideIndicator();
73321     } catch (std::out_of_range& e) {
73322       {
73323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73324       };
73325     } catch (std::exception& e) {
73326       {
73327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73328       };
73329     } catch (Dali::DaliException e) {
73330       {
73331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73332       };
73333     } catch (...) {
73334       {
73335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73336       };
73337     }
73338   }
73339
73340 }
73341
73342
73343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73344   void * jresult ;
73345   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73346   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73347
73348   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73349   {
73350     try {
73351       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73352     } catch (std::out_of_range& e) {
73353       {
73354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73355       };
73356     } catch (std::exception& e) {
73357       {
73358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73359       };
73360     } catch (Dali::DaliException e) {
73361       {
73362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73363       };
73364     } catch (...) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73367       };
73368     }
73369   }
73370
73371   jresult = (void *)result;
73372   return jresult;
73373 }
73374
73375
73376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73377   void * jresult ;
73378   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73379   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73380
73381   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73382   {
73383     try {
73384       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73385     } catch (std::out_of_range& e) {
73386       {
73387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73388       };
73389     } catch (std::exception& e) {
73390       {
73391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73392       };
73393     } catch (Dali::DaliException e) {
73394       {
73395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73396       };
73397     } catch (...) {
73398       {
73399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73400       };
73401     }
73402   }
73403
73404   jresult = (void *)result;
73405   return jresult;
73406 }
73407
73408
73409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73410   int jresult ;
73411   int result;
73412
73413   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73414   jresult = (int)result;
73415   return jresult;
73416 }
73417
73418
73419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73420   int jresult ;
73421   int result;
73422
73423   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73424   jresult = (int)result;
73425   return jresult;
73426 }
73427
73428
73429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73430   int jresult ;
73431   int result;
73432
73433   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73434   jresult = (int)result;
73435   return jresult;
73436 }
73437
73438
73439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73440   int jresult ;
73441   int result;
73442
73443   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73444   jresult = (int)result;
73445   return jresult;
73446 }
73447
73448
73449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73450   int jresult ;
73451   int result;
73452
73453   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73454   jresult = (int)result;
73455   return jresult;
73456 }
73457
73458
73459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73460   int jresult ;
73461   int result;
73462
73463   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73464   jresult = (int)result;
73465   return jresult;
73466 }
73467
73468
73469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73470   int jresult ;
73471   int result;
73472
73473   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73474   jresult = (int)result;
73475   return jresult;
73476 }
73477
73478
73479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73480   int jresult ;
73481   int result;
73482
73483   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73484   jresult = (int)result;
73485   return jresult;
73486 }
73487
73488
73489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73490   int jresult ;
73491   int result;
73492
73493   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73494   jresult = (int)result;
73495   return jresult;
73496 }
73497
73498
73499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73500   int jresult ;
73501   int result;
73502
73503   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73504   jresult = (int)result;
73505   return jresult;
73506 }
73507
73508
73509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73510   int jresult ;
73511   int result;
73512
73513   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73514   jresult = (int)result;
73515   return jresult;
73516 }
73517
73518
73519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73520   int jresult ;
73521   int result;
73522
73523   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73524   jresult = (int)result;
73525   return jresult;
73526 }
73527
73528
73529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73530   int jresult ;
73531   int result;
73532
73533   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73534   jresult = (int)result;
73535   return jresult;
73536 }
73537
73538
73539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73540   int jresult ;
73541   int result;
73542
73543   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73544   jresult = (int)result;
73545   return jresult;
73546 }
73547
73548
73549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73550   void * jresult ;
73551   Dali::Toolkit::Scrollable::Property *result = 0 ;
73552
73553   {
73554     try {
73555       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73556     } catch (std::out_of_range& e) {
73557       {
73558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73559       };
73560     } catch (std::exception& e) {
73561       {
73562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73563       };
73564     } catch (Dali::DaliException e) {
73565       {
73566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73567       };
73568     } catch (...) {
73569       {
73570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73571       };
73572     }
73573   }
73574
73575   jresult = (void *)result;
73576   return jresult;
73577 }
73578
73579
73580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73581   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73582
73583   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73584   {
73585     try {
73586       delete arg1;
73587     } catch (std::out_of_range& e) {
73588       {
73589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73590       };
73591     } catch (std::exception& e) {
73592       {
73593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73594       };
73595     } catch (Dali::DaliException e) {
73596       {
73597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73598       };
73599     } catch (...) {
73600       {
73601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73602       };
73603     }
73604   }
73605
73606 }
73607
73608
73609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73610   void * jresult ;
73611   Dali::Toolkit::Scrollable *result = 0 ;
73612
73613   {
73614     try {
73615       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73616     } catch (std::out_of_range& e) {
73617       {
73618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73619       };
73620     } catch (std::exception& e) {
73621       {
73622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73623       };
73624     } catch (Dali::DaliException e) {
73625       {
73626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73627       };
73628     } catch (...) {
73629       {
73630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73631       };
73632     }
73633   }
73634
73635   jresult = (void *)result;
73636   return jresult;
73637 }
73638
73639
73640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73641   void * jresult ;
73642   Dali::Toolkit::Scrollable *arg1 = 0 ;
73643   Dali::Toolkit::Scrollable *result = 0 ;
73644
73645   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73646   if (!arg1) {
73647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73648     return 0;
73649   }
73650   {
73651     try {
73652       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73653     } catch (std::out_of_range& e) {
73654       {
73655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73656       };
73657     } catch (std::exception& e) {
73658       {
73659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73660       };
73661     } catch (Dali::DaliException e) {
73662       {
73663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73664       };
73665     } catch (...) {
73666       {
73667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73668       };
73669     }
73670   }
73671
73672   jresult = (void *)result;
73673   return jresult;
73674 }
73675
73676
73677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73678   void * jresult ;
73679   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73680   Dali::Toolkit::Scrollable *arg2 = 0 ;
73681   Dali::Toolkit::Scrollable *result = 0 ;
73682
73683   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73684   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73685   if (!arg2) {
73686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73687     return 0;
73688   }
73689   {
73690     try {
73691       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73692     } catch (std::out_of_range& e) {
73693       {
73694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73695       };
73696     } catch (std::exception& e) {
73697       {
73698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73699       };
73700     } catch (Dali::DaliException e) {
73701       {
73702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73703       };
73704     } catch (...) {
73705       {
73706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73707       };
73708     }
73709   }
73710
73711   jresult = (void *)result;
73712   return jresult;
73713 }
73714
73715
73716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73717   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73718
73719   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73720   {
73721     try {
73722       delete arg1;
73723     } catch (std::out_of_range& e) {
73724       {
73725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73726       };
73727     } catch (std::exception& e) {
73728       {
73729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73730       };
73731     } catch (Dali::DaliException e) {
73732       {
73733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73734       };
73735     } catch (...) {
73736       {
73737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73738       };
73739     }
73740   }
73741
73742 }
73743
73744
73745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73746   void * jresult ;
73747   Dali::BaseHandle arg1 ;
73748   Dali::BaseHandle *argp1 ;
73749   Dali::Toolkit::Scrollable result;
73750
73751   argp1 = (Dali::BaseHandle *)jarg1;
73752   if (!argp1) {
73753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73754     return 0;
73755   }
73756   arg1 = *argp1;
73757   {
73758     try {
73759       result = Dali::Toolkit::Scrollable::DownCast(arg1);
73760     } catch (std::out_of_range& e) {
73761       {
73762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73763       };
73764     } catch (std::exception& e) {
73765       {
73766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73767       };
73768     } catch (Dali::DaliException e) {
73769       {
73770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73771       };
73772     } catch (...) {
73773       {
73774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73775       };
73776     }
73777   }
73778
73779   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
73780   return jresult;
73781 }
73782
73783
73784 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
73785   unsigned int jresult ;
73786   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73787   bool result;
73788
73789   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73790   {
73791     try {
73792       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
73793     } catch (std::out_of_range& e) {
73794       {
73795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73796       };
73797     } catch (std::exception& e) {
73798       {
73799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73800       };
73801     } catch (Dali::DaliException e) {
73802       {
73803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73804       };
73805     } catch (...) {
73806       {
73807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73808       };
73809     }
73810   }
73811
73812   jresult = result;
73813   return jresult;
73814 }
73815
73816
73817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
73818   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73819   bool arg2 ;
73820
73821   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73822   arg2 = jarg2 ? true : false;
73823   {
73824     try {
73825       (arg1)->SetOvershootEnabled(arg2);
73826     } catch (std::out_of_range& e) {
73827       {
73828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73829       };
73830     } catch (std::exception& e) {
73831       {
73832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73833       };
73834     } catch (Dali::DaliException e) {
73835       {
73836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73837       };
73838     } catch (...) {
73839       {
73840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73841       };
73842     }
73843   }
73844
73845 }
73846
73847
73848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73849   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73850   Dali::Vector4 *arg2 = 0 ;
73851
73852   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73853   arg2 = (Dali::Vector4 *)jarg2;
73854   if (!arg2) {
73855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73856     return ;
73857   }
73858   {
73859     try {
73860       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73861     } catch (std::out_of_range& e) {
73862       {
73863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73864       };
73865     } catch (std::exception& e) {
73866       {
73867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73868       };
73869     } catch (Dali::DaliException e) {
73870       {
73871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73872       };
73873     } catch (...) {
73874       {
73875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73876       };
73877     }
73878   }
73879
73880 }
73881
73882
73883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73884   void * jresult ;
73885   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73886   Dali::Vector4 result;
73887
73888   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73889   {
73890     try {
73891       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73892     } catch (std::out_of_range& e) {
73893       {
73894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73895       };
73896     } catch (std::exception& e) {
73897       {
73898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73899       };
73900     } catch (Dali::DaliException e) {
73901       {
73902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73903       };
73904     } catch (...) {
73905       {
73906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73907       };
73908     }
73909   }
73910
73911   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73912   return jresult;
73913 }
73914
73915
73916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73917   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73918   float arg2 ;
73919
73920   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73921   arg2 = (float)jarg2;
73922   {
73923     try {
73924       (arg1)->SetOvershootAnimationSpeed(arg2);
73925     } catch (std::out_of_range& e) {
73926       {
73927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73928       };
73929     } catch (std::exception& e) {
73930       {
73931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73932       };
73933     } catch (Dali::DaliException e) {
73934       {
73935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73936       };
73937     } catch (...) {
73938       {
73939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73940       };
73941     }
73942   }
73943
73944 }
73945
73946
73947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73948   float jresult ;
73949   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73950   float result;
73951
73952   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73953   {
73954     try {
73955       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73956     } catch (std::out_of_range& e) {
73957       {
73958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73959       };
73960     } catch (std::exception& e) {
73961       {
73962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73963       };
73964     } catch (Dali::DaliException e) {
73965       {
73966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73967       };
73968     } catch (...) {
73969       {
73970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73971       };
73972     }
73973   }
73974
73975   jresult = result;
73976   return jresult;
73977 }
73978
73979
73980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73981   void * jresult ;
73982   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73983   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73984
73985   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73986   {
73987     try {
73988       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73989     } catch (std::out_of_range& e) {
73990       {
73991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73992       };
73993     } catch (std::exception& e) {
73994       {
73995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73996       };
73997     } catch (Dali::DaliException e) {
73998       {
73999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74000       };
74001     } catch (...) {
74002       {
74003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74004       };
74005     }
74006   }
74007
74008   jresult = (void *)result;
74009   return jresult;
74010 }
74011
74012
74013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
74014   void * jresult ;
74015   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74016   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
74017
74018   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74019   {
74020     try {
74021       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
74022     } catch (std::out_of_range& e) {
74023       {
74024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74025       };
74026     } catch (std::exception& e) {
74027       {
74028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74029       };
74030     } catch (Dali::DaliException e) {
74031       {
74032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74033       };
74034     } catch (...) {
74035       {
74036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74037       };
74038     }
74039   }
74040
74041   jresult = (void *)result;
74042   return jresult;
74043 }
74044
74045
74046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74047   void * jresult ;
74048   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74049   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74050
74051   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74052   {
74053     try {
74054       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74055     } catch (std::out_of_range& e) {
74056       {
74057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74058       };
74059     } catch (std::exception& e) {
74060       {
74061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74062       };
74063     } catch (Dali::DaliException e) {
74064       {
74065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74066       };
74067     } catch (...) {
74068       {
74069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74070       };
74071     }
74072   }
74073
74074   jresult = (void *)result;
74075   return jresult;
74076 }
74077
74078
74079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74080   unsigned int jresult ;
74081   Dali::Toolkit::ControlOrientation::Type arg1 ;
74082   bool result;
74083
74084   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74085   {
74086     try {
74087       result = (bool)Dali::Toolkit::IsVertical(arg1);
74088     } catch (std::out_of_range& e) {
74089       {
74090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74091       };
74092     } catch (std::exception& e) {
74093       {
74094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74095       };
74096     } catch (Dali::DaliException e) {
74097       {
74098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74099       };
74100     } catch (...) {
74101       {
74102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74103       };
74104     }
74105   }
74106
74107   jresult = result;
74108   return jresult;
74109 }
74110
74111
74112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74113   unsigned int jresult ;
74114   Dali::Toolkit::ControlOrientation::Type arg1 ;
74115   bool result;
74116
74117   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74118   {
74119     try {
74120       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74121     } catch (std::out_of_range& e) {
74122       {
74123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74124       };
74125     } catch (std::exception& e) {
74126       {
74127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74128       };
74129     } catch (Dali::DaliException e) {
74130       {
74131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74132       };
74133     } catch (...) {
74134       {
74135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74136       };
74137     }
74138   }
74139
74140   jresult = result;
74141   return jresult;
74142 }
74143
74144
74145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74146   void * jresult ;
74147   unsigned int arg1 ;
74148   unsigned int arg2 ;
74149   Dali::Toolkit::ItemRange *result = 0 ;
74150
74151   arg1 = (unsigned int)jarg1;
74152   arg2 = (unsigned int)jarg2;
74153   {
74154     try {
74155       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74156     } catch (std::out_of_range& e) {
74157       {
74158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74159       };
74160     } catch (std::exception& e) {
74161       {
74162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74163       };
74164     } catch (Dali::DaliException e) {
74165       {
74166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74167       };
74168     } catch (...) {
74169       {
74170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74171       };
74172     }
74173   }
74174
74175   jresult = (void *)result;
74176   return jresult;
74177 }
74178
74179
74180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74181   void * jresult ;
74182   Dali::Toolkit::ItemRange *arg1 = 0 ;
74183   Dali::Toolkit::ItemRange *result = 0 ;
74184
74185   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74186   if (!arg1) {
74187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74188     return 0;
74189   }
74190   {
74191     try {
74192       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74193     } catch (std::out_of_range& e) {
74194       {
74195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74196       };
74197     } catch (std::exception& e) {
74198       {
74199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74200       };
74201     } catch (Dali::DaliException e) {
74202       {
74203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74204       };
74205     } catch (...) {
74206       {
74207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74208       };
74209     }
74210   }
74211
74212   jresult = (void *)result;
74213   return jresult;
74214 }
74215
74216
74217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74218   void * jresult ;
74219   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74220   Dali::Toolkit::ItemRange *arg2 = 0 ;
74221   Dali::Toolkit::ItemRange *result = 0 ;
74222
74223   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74224   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74225   if (!arg2) {
74226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74227     return 0;
74228   }
74229   {
74230     try {
74231       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74232     } catch (std::out_of_range& e) {
74233       {
74234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74235       };
74236     } catch (std::exception& e) {
74237       {
74238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74239       };
74240     } catch (Dali::DaliException e) {
74241       {
74242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74243       };
74244     } catch (...) {
74245       {
74246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74247       };
74248     }
74249   }
74250
74251   jresult = (void *)result;
74252   return jresult;
74253 }
74254
74255
74256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74257   unsigned int jresult ;
74258   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74259   unsigned int arg2 ;
74260   bool result;
74261
74262   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74263   arg2 = (unsigned int)jarg2;
74264   {
74265     try {
74266       result = (bool)(arg1)->Within(arg2);
74267     } catch (std::out_of_range& e) {
74268       {
74269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74270       };
74271     } catch (std::exception& e) {
74272       {
74273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74274       };
74275     } catch (Dali::DaliException e) {
74276       {
74277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74278       };
74279     } catch (...) {
74280       {
74281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74282       };
74283     }
74284   }
74285
74286   jresult = result;
74287   return jresult;
74288 }
74289
74290
74291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74292   void * jresult ;
74293   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74294   Dali::Toolkit::ItemRange *arg2 = 0 ;
74295   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74296
74297   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74298   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74299   if (!arg2) {
74300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74301     return 0;
74302   }
74303   {
74304     try {
74305       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74306     } catch (std::out_of_range& e) {
74307       {
74308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74309       };
74310     } catch (std::exception& e) {
74311       {
74312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74313       };
74314     } catch (Dali::DaliException e) {
74315       {
74316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74317       };
74318     } catch (...) {
74319       {
74320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74321       };
74322     }
74323   }
74324
74325   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74326   return jresult;
74327 }
74328
74329
74330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74331   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74332   unsigned int arg2 ;
74333
74334   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74335   arg2 = (unsigned int)jarg2;
74336   if (arg1) (arg1)->begin = arg2;
74337 }
74338
74339
74340 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74341   unsigned int jresult ;
74342   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74343   unsigned int result;
74344
74345   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74346   result = (unsigned int) ((arg1)->begin);
74347   jresult = result;
74348   return jresult;
74349 }
74350
74351
74352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74353   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74354   unsigned int arg2 ;
74355
74356   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74357   arg2 = (unsigned int)jarg2;
74358   if (arg1) (arg1)->end = arg2;
74359 }
74360
74361
74362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74363   unsigned int jresult ;
74364   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74365   unsigned int result;
74366
74367   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74368   result = (unsigned int) ((arg1)->end);
74369   jresult = result;
74370   return jresult;
74371 }
74372
74373
74374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74375   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74376
74377   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74378   {
74379     try {
74380       delete arg1;
74381     } catch (std::out_of_range& e) {
74382       {
74383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74384       };
74385     } catch (std::exception& e) {
74386       {
74387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74388       };
74389     } catch (Dali::DaliException e) {
74390       {
74391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74392       };
74393     } catch (...) {
74394       {
74395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74396       };
74397     }
74398   }
74399
74400 }
74401
74402
74403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74404   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74405
74406   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74407   {
74408     try {
74409       delete arg1;
74410     } catch (std::out_of_range& e) {
74411       {
74412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74413       };
74414     } catch (std::exception& e) {
74415       {
74416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74417       };
74418     } catch (Dali::DaliException e) {
74419       {
74420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74421       };
74422     } catch (...) {
74423       {
74424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74425       };
74426     }
74427   }
74428
74429 }
74430
74431
74432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74433   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74434   Dali::Toolkit::ControlOrientation::Type arg2 ;
74435
74436   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74437   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74438   {
74439     try {
74440       (arg1)->SetOrientation(arg2);
74441     } catch (std::out_of_range& e) {
74442       {
74443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74444       };
74445     } catch (std::exception& e) {
74446       {
74447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74448       };
74449     } catch (Dali::DaliException e) {
74450       {
74451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74452       };
74453     } catch (...) {
74454       {
74455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74456       };
74457     }
74458   }
74459
74460 }
74461
74462
74463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74464   int jresult ;
74465   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74466   Dali::Toolkit::ControlOrientation::Type result;
74467
74468   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74469   {
74470     try {
74471       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74472     } catch (std::out_of_range& e) {
74473       {
74474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74475       };
74476     } catch (std::exception& e) {
74477       {
74478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74479       };
74480     } catch (Dali::DaliException e) {
74481       {
74482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74483       };
74484     } catch (...) {
74485       {
74486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74487       };
74488     }
74489   }
74490
74491   jresult = (int)result;
74492   return jresult;
74493 }
74494
74495
74496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74497   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74498   Dali::Property::Map *arg2 = 0 ;
74499
74500   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74501   arg2 = (Dali::Property::Map *)jarg2;
74502   if (!arg2) {
74503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74504     return ;
74505   }
74506   {
74507     try {
74508       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74509     } catch (std::out_of_range& e) {
74510       {
74511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74512       };
74513     } catch (std::exception& e) {
74514       {
74515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74516       };
74517     } catch (Dali::DaliException e) {
74518       {
74519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74520       };
74521     } catch (...) {
74522       {
74523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74524       };
74525     }
74526   }
74527
74528 }
74529
74530
74531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74532   void * jresult ;
74533   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74534   Dali::Property::Map result;
74535
74536   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74537   {
74538     try {
74539       result = (arg1)->GetLayoutProperties();
74540     } catch (std::out_of_range& e) {
74541       {
74542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74543       };
74544     } catch (std::exception& e) {
74545       {
74546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74547       };
74548     } catch (Dali::DaliException e) {
74549       {
74550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74551       };
74552     } catch (...) {
74553       {
74554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74555       };
74556     }
74557   }
74558
74559   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74560   return jresult;
74561 }
74562
74563
74564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74565   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74566   unsigned int arg2 ;
74567   Dali::Vector3 *arg3 = 0 ;
74568   Dali::Vector3 *arg4 = 0 ;
74569
74570   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74571   arg2 = (unsigned int)jarg2;
74572   arg3 = (Dali::Vector3 *)jarg3;
74573   if (!arg3) {
74574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74575     return ;
74576   }
74577   arg4 = (Dali::Vector3 *)jarg4;
74578   if (!arg4) {
74579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74580     return ;
74581   }
74582   {
74583     try {
74584       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74585     } catch (std::out_of_range& e) {
74586       {
74587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74588       };
74589     } catch (std::exception& e) {
74590       {
74591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74592       };
74593     } catch (Dali::DaliException e) {
74594       {
74595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74596       };
74597     } catch (...) {
74598       {
74599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74600       };
74601     }
74602   }
74603
74604 }
74605
74606
74607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74608   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74609   Dali::Vector3 *arg2 = 0 ;
74610
74611   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74612   arg2 = (Dali::Vector3 *)jarg2;
74613   if (!arg2) {
74614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74615     return ;
74616   }
74617   {
74618     try {
74619       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74620     } catch (std::out_of_range& e) {
74621       {
74622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74623       };
74624     } catch (std::exception& e) {
74625       {
74626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74627       };
74628     } catch (Dali::DaliException e) {
74629       {
74630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74631       };
74632     } catch (...) {
74633       {
74634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74635       };
74636     }
74637   }
74638
74639 }
74640
74641
74642 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74643   float jresult ;
74644   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74645   unsigned int arg2 ;
74646   Dali::Vector3 arg3 ;
74647   Dali::Vector3 *argp3 ;
74648   float result;
74649
74650   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74651   arg2 = (unsigned int)jarg2;
74652   argp3 = (Dali::Vector3 *)jarg3;
74653   if (!argp3) {
74654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74655     return 0;
74656   }
74657   arg3 = *argp3;
74658   {
74659     try {
74660       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74661     } catch (std::out_of_range& e) {
74662       {
74663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74664       };
74665     } catch (std::exception& e) {
74666       {
74667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74668       };
74669     } catch (Dali::DaliException e) {
74670       {
74671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74672       };
74673     } catch (...) {
74674       {
74675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74676       };
74677     }
74678   }
74679
74680   jresult = result;
74681   return jresult;
74682 }
74683
74684
74685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74686   float jresult ;
74687   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74688   float arg2 ;
74689   float result;
74690
74691   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74692   arg2 = (float)jarg2;
74693   {
74694     try {
74695       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74696     } catch (std::out_of_range& e) {
74697       {
74698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74699       };
74700     } catch (std::exception& e) {
74701       {
74702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74703       };
74704     } catch (Dali::DaliException e) {
74705       {
74706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74707       };
74708     } catch (...) {
74709       {
74710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74711       };
74712     }
74713   }
74714
74715   jresult = result;
74716   return jresult;
74717 }
74718
74719
74720 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74721   float jresult ;
74722   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74723   unsigned int arg2 ;
74724   float result;
74725
74726   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74727   arg2 = (unsigned int)jarg2;
74728   {
74729     try {
74730       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74731     } catch (std::out_of_range& e) {
74732       {
74733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74734       };
74735     } catch (std::exception& e) {
74736       {
74737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74738       };
74739     } catch (Dali::DaliException e) {
74740       {
74741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74742       };
74743     } catch (...) {
74744       {
74745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74746       };
74747     }
74748   }
74749
74750   jresult = result;
74751   return jresult;
74752 }
74753
74754
74755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
74756   void * jresult ;
74757   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74758   float arg2 ;
74759   Dali::Vector3 arg3 ;
74760   Dali::Vector3 *argp3 ;
74761   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74762
74763   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74764   arg2 = (float)jarg2;
74765   argp3 = (Dali::Vector3 *)jarg3;
74766   if (!argp3) {
74767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74768     return 0;
74769   }
74770   arg3 = *argp3;
74771   {
74772     try {
74773       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
74774     } catch (std::out_of_range& e) {
74775       {
74776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74777       };
74778     } catch (std::exception& e) {
74779       {
74780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74781       };
74782     } catch (Dali::DaliException e) {
74783       {
74784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74785       };
74786     } catch (...) {
74787       {
74788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74789       };
74790     }
74791   }
74792
74793   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74794   return jresult;
74795 }
74796
74797
74798 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74799   float jresult ;
74800   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74801   int arg2 ;
74802   float arg3 ;
74803   Dali::Vector3 *arg4 = 0 ;
74804   float result;
74805
74806   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74807   arg2 = (int)jarg2;
74808   arg3 = (float)jarg3;
74809   arg4 = (Dali::Vector3 *)jarg4;
74810   if (!arg4) {
74811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74812     return 0;
74813   }
74814   {
74815     try {
74816       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74817     } catch (std::out_of_range& e) {
74818       {
74819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74820       };
74821     } catch (std::exception& e) {
74822       {
74823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74824       };
74825     } catch (Dali::DaliException e) {
74826       {
74827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74828       };
74829     } catch (...) {
74830       {
74831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74832       };
74833     }
74834   }
74835
74836   jresult = result;
74837   return jresult;
74838 }
74839
74840
74841 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
74842   unsigned int jresult ;
74843   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74844   Dali::Vector3 arg2 ;
74845   Dali::Vector3 *argp2 ;
74846   unsigned int result;
74847
74848   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74849   argp2 = (Dali::Vector3 *)jarg2;
74850   if (!argp2) {
74851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74852     return 0;
74853   }
74854   arg2 = *argp2;
74855   {
74856     try {
74857       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74858     } catch (std::out_of_range& e) {
74859       {
74860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74861       };
74862     } catch (std::exception& e) {
74863       {
74864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74865       };
74866     } catch (Dali::DaliException e) {
74867       {
74868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74869       };
74870     } catch (...) {
74871       {
74872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74873       };
74874     }
74875   }
74876
74877   jresult = result;
74878   return jresult;
74879 }
74880
74881
74882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74883   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74884   unsigned int arg2 ;
74885   Dali::Vector3 *arg3 = 0 ;
74886   Dali::Vector3 *arg4 = 0 ;
74887
74888   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74889   arg2 = (unsigned int)jarg2;
74890   arg3 = (Dali::Vector3 *)jarg3;
74891   if (!arg3) {
74892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74893     return ;
74894   }
74895   arg4 = (Dali::Vector3 *)jarg4;
74896   if (!arg4) {
74897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74898     return ;
74899   }
74900   {
74901     try {
74902       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74903     } catch (std::out_of_range& e) {
74904       {
74905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74906       };
74907     } catch (std::exception& e) {
74908       {
74909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74910       };
74911     } catch (Dali::DaliException e) {
74912       {
74913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74914       };
74915     } catch (...) {
74916       {
74917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74918       };
74919     }
74920   }
74921
74922 }
74923
74924
74925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74926   void * jresult ;
74927   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74928   Dali::Degree result;
74929
74930   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74931   {
74932     try {
74933       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74934     } catch (std::out_of_range& e) {
74935       {
74936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74937       };
74938     } catch (std::exception& e) {
74939       {
74940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74941       };
74942     } catch (Dali::DaliException e) {
74943       {
74944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74945       };
74946     } catch (...) {
74947       {
74948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74949       };
74950     }
74951   }
74952
74953   jresult = new Dali::Degree((const Dali::Degree &)result);
74954   return jresult;
74955 }
74956
74957
74958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74959   float jresult ;
74960   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74961   float result;
74962
74963   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74964   {
74965     try {
74966       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74967     } catch (std::out_of_range& e) {
74968       {
74969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74970       };
74971     } catch (std::exception& e) {
74972       {
74973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74974       };
74975     } catch (Dali::DaliException e) {
74976       {
74977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74978       };
74979     } catch (...) {
74980       {
74981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74982       };
74983     }
74984   }
74985
74986   jresult = result;
74987   return jresult;
74988 }
74989
74990
74991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74992   float jresult ;
74993   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74994   float result;
74995
74996   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74997   {
74998     try {
74999       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
75000     } catch (std::out_of_range& e) {
75001       {
75002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75003       };
75004     } catch (std::exception& e) {
75005       {
75006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75007       };
75008     } catch (Dali::DaliException e) {
75009       {
75010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75011       };
75012     } catch (...) {
75013       {
75014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75015       };
75016     }
75017   }
75018
75019   jresult = result;
75020   return jresult;
75021 }
75022
75023
75024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
75025   float jresult ;
75026   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75027   float result;
75028
75029   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75030   {
75031     try {
75032       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
75033     } catch (std::out_of_range& e) {
75034       {
75035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75036       };
75037     } catch (std::exception& e) {
75038       {
75039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75040       };
75041     } catch (Dali::DaliException e) {
75042       {
75043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75044       };
75045     } catch (...) {
75046       {
75047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75048       };
75049     }
75050   }
75051
75052   jresult = result;
75053   return jresult;
75054 }
75055
75056
75057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75058   int jresult ;
75059   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75060   int arg2 ;
75061   int arg3 ;
75062   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75063   bool arg5 ;
75064   int result;
75065
75066   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75067   arg2 = (int)jarg2;
75068   arg3 = (int)jarg3;
75069   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75070   arg5 = jarg5 ? true : false;
75071   {
75072     try {
75073       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75074     } catch (std::out_of_range& e) {
75075       {
75076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75077       };
75078     } catch (std::exception& e) {
75079       {
75080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75081       };
75082     } catch (Dali::DaliException e) {
75083       {
75084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75085       };
75086     } catch (...) {
75087       {
75088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75089       };
75090     }
75091   }
75092
75093   jresult = result;
75094   return jresult;
75095 }
75096
75097
75098 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75099   float jresult ;
75100   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75101   float result;
75102
75103   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75104   {
75105     try {
75106       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75107     } catch (std::out_of_range& e) {
75108       {
75109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75110       };
75111     } catch (std::exception& e) {
75112       {
75113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75114       };
75115     } catch (Dali::DaliException e) {
75116       {
75117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75118       };
75119     } catch (...) {
75120       {
75121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75122       };
75123     }
75124   }
75125
75126   jresult = result;
75127   return jresult;
75128 }
75129
75130
75131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75132   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75133   Dali::Actor *arg2 = 0 ;
75134   int arg3 ;
75135   Dali::Vector3 *arg4 = 0 ;
75136   Dali::Actor *arg5 = 0 ;
75137
75138   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75139   arg2 = (Dali::Actor *)jarg2;
75140   if (!arg2) {
75141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75142     return ;
75143   }
75144   arg3 = (int)jarg3;
75145   arg4 = (Dali::Vector3 *)jarg4;
75146   if (!arg4) {
75147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75148     return ;
75149   }
75150   arg5 = (Dali::Actor *)jarg5;
75151   if (!arg5) {
75152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75153     return ;
75154   }
75155   {
75156     try {
75157       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75158     } catch (std::out_of_range& e) {
75159       {
75160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75161       };
75162     } catch (std::exception& e) {
75163       {
75164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75165       };
75166     } catch (Dali::DaliException e) {
75167       {
75168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75169       };
75170     } catch (...) {
75171       {
75172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75173       };
75174     }
75175   }
75176
75177 }
75178
75179
75180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75181   void * jresult ;
75182   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75183   int arg2 ;
75184   float arg3 ;
75185   Dali::Vector3 *arg4 = 0 ;
75186   Dali::Vector3 result;
75187
75188   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75189   arg2 = (int)jarg2;
75190   arg3 = (float)jarg3;
75191   arg4 = (Dali::Vector3 *)jarg4;
75192   if (!arg4) {
75193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75194     return 0;
75195   }
75196   {
75197     try {
75198       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75199     } catch (std::out_of_range& e) {
75200       {
75201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75202       };
75203     } catch (std::exception& e) {
75204       {
75205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75206       };
75207     } catch (Dali::DaliException e) {
75208       {
75209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75210       };
75211     } catch (...) {
75212       {
75213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75214       };
75215     }
75216   }
75217
75218   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75219   return jresult;
75220 }
75221
75222
75223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75224   void * jresult ;
75225   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75226   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75227
75228   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75229   {
75230     try {
75231       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75232     } catch (std::out_of_range& e) {
75233       {
75234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75235       };
75236     } catch (std::exception& e) {
75237       {
75238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75239       };
75240     } catch (Dali::DaliException e) {
75241       {
75242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75243       };
75244     } catch (...) {
75245       {
75246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75247       };
75248     }
75249   }
75250
75251   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75252   return jresult;
75253 }
75254
75255
75256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75257   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75258
75259   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75260   {
75261     try {
75262       delete arg1;
75263     } catch (std::out_of_range& e) {
75264       {
75265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75266       };
75267     } catch (std::exception& e) {
75268       {
75269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75270       };
75271     } catch (Dali::DaliException e) {
75272       {
75273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75274       };
75275     } catch (...) {
75276       {
75277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75278       };
75279     }
75280   }
75281
75282 }
75283
75284
75285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75286   unsigned int jresult ;
75287   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75288   unsigned int result;
75289
75290   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75291   {
75292     try {
75293       result = (unsigned int)(arg1)->GetNumberOfItems();
75294     } catch (std::out_of_range& e) {
75295       {
75296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75297       };
75298     } catch (std::exception& e) {
75299       {
75300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75301       };
75302     } catch (Dali::DaliException e) {
75303       {
75304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75305       };
75306     } catch (...) {
75307       {
75308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75309       };
75310     }
75311   }
75312
75313   jresult = result;
75314   return jresult;
75315 }
75316
75317
75318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75319   void * jresult ;
75320   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75321   unsigned int arg2 ;
75322   Dali::Actor result;
75323
75324   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75325   arg2 = (unsigned int)jarg2;
75326   {
75327     try {
75328       result = (arg1)->NewItem(arg2);
75329     } catch (std::out_of_range& e) {
75330       {
75331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75332       };
75333     } catch (std::exception& e) {
75334       {
75335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75336       };
75337     } catch (Dali::DaliException e) {
75338       {
75339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75340       };
75341     } catch (...) {
75342       {
75343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75344       };
75345     }
75346   }
75347
75348   jresult = new Dali::Actor((const Dali::Actor &)result);
75349   return jresult;
75350 }
75351
75352
75353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75354   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75355   unsigned int arg2 ;
75356   Dali::Actor arg3 ;
75357   Dali::Actor *argp3 ;
75358
75359   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75360   arg2 = (unsigned int)jarg2;
75361   argp3 = (Dali::Actor *)jarg3;
75362   if (!argp3) {
75363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75364     return ;
75365   }
75366   arg3 = *argp3;
75367   {
75368     try {
75369       (arg1)->ItemReleased(arg2,arg3);
75370     } catch (std::out_of_range& e) {
75371       {
75372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75373       };
75374     } catch (std::exception& e) {
75375       {
75376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75377       };
75378     } catch (Dali::DaliException e) {
75379       {
75380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75381       };
75382     } catch (...) {
75383       {
75384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75385       };
75386     }
75387   }
75388
75389 }
75390
75391
75392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75393   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75394   unsigned int arg2 ;
75395   Dali::Actor arg3 ;
75396   Dali::Actor *argp3 ;
75397
75398   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75399   arg2 = (unsigned int)jarg2;
75400   argp3 = (Dali::Actor *)jarg3;
75401   if (!argp3) {
75402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75403     return ;
75404   }
75405   arg3 = *argp3;
75406   {
75407     try {
75408       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75409     } catch (std::out_of_range& e) {
75410       {
75411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75412       };
75413     } catch (std::exception& e) {
75414       {
75415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75416       };
75417     } catch (Dali::DaliException e) {
75418       {
75419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75420       };
75421     } catch (...) {
75422       {
75423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75424       };
75425     }
75426   }
75427
75428 }
75429
75430
75431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75432   void * jresult ;
75433   Dali::Toolkit::ItemFactory *result = 0 ;
75434
75435   {
75436     try {
75437       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75438     } catch (std::out_of_range& e) {
75439       {
75440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75441       };
75442     } catch (std::exception& e) {
75443       {
75444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75445       };
75446     } catch (Dali::DaliException e) {
75447       {
75448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75449       };
75450     } catch (...) {
75451       {
75452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75453       };
75454     }
75455   }
75456
75457   jresult = (void *)result;
75458   return jresult;
75459 }
75460
75461
75462 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) {
75463   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75464   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75465   if (director) {
75466     director->swig_connect_director(callback0, callback1, callback2);
75467   }
75468 }
75469
75470
75471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75472   int jresult ;
75473   int result;
75474
75475   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75476   jresult = (int)result;
75477   return jresult;
75478 }
75479
75480
75481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75482   int jresult ;
75483   int result;
75484
75485   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75486   jresult = (int)result;
75487   return jresult;
75488 }
75489
75490
75491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75492   int jresult ;
75493   int result;
75494
75495   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75496   jresult = (int)result;
75497   return jresult;
75498 }
75499
75500
75501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75502   int jresult ;
75503   int result;
75504
75505   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75506   jresult = (int)result;
75507   return jresult;
75508 }
75509
75510
75511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75512   int jresult ;
75513   int result;
75514
75515   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75516   jresult = (int)result;
75517   return jresult;
75518 }
75519
75520
75521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75522   int jresult ;
75523   int result;
75524
75525   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75526   jresult = (int)result;
75527   return jresult;
75528 }
75529
75530
75531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75532   int jresult ;
75533   int result;
75534
75535   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75536   jresult = (int)result;
75537   return jresult;
75538 }
75539
75540
75541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75542   int jresult ;
75543   int result;
75544
75545   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75546   jresult = (int)result;
75547   return jresult;
75548 }
75549
75550
75551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75552   int jresult ;
75553   int result;
75554
75555   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75556   jresult = (int)result;
75557   return jresult;
75558 }
75559
75560
75561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75562   int jresult ;
75563   int result;
75564
75565   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75566   jresult = (int)result;
75567   return jresult;
75568 }
75569
75570
75571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75572   int jresult ;
75573   int result;
75574
75575   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75576   jresult = (int)result;
75577   return jresult;
75578 }
75579
75580
75581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75582   void * jresult ;
75583   Dali::Toolkit::ItemView::Property *result = 0 ;
75584
75585   {
75586     try {
75587       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
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 = (void *)result;
75608   return jresult;
75609 }
75610
75611
75612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75613   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75614
75615   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75616   {
75617     try {
75618       delete arg1;
75619     } catch (std::out_of_range& e) {
75620       {
75621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75622       };
75623     } catch (std::exception& e) {
75624       {
75625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75626       };
75627     } catch (Dali::DaliException e) {
75628       {
75629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75630       };
75631     } catch (...) {
75632       {
75633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75634       };
75635     }
75636   }
75637
75638 }
75639
75640
75641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75642   void * jresult ;
75643   Dali::Toolkit::ItemView *result = 0 ;
75644
75645   {
75646     try {
75647       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75648     } catch (std::out_of_range& e) {
75649       {
75650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75651       };
75652     } catch (std::exception& e) {
75653       {
75654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75655       };
75656     } catch (Dali::DaliException e) {
75657       {
75658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75659       };
75660     } catch (...) {
75661       {
75662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75663       };
75664     }
75665   }
75666
75667   jresult = (void *)result;
75668   return jresult;
75669 }
75670
75671
75672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75673   void * jresult ;
75674   Dali::Toolkit::ItemView *arg1 = 0 ;
75675   Dali::Toolkit::ItemView *result = 0 ;
75676
75677   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75678   if (!arg1) {
75679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75680     return 0;
75681   }
75682   {
75683     try {
75684       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75685     } catch (std::out_of_range& e) {
75686       {
75687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75688       };
75689     } catch (std::exception& e) {
75690       {
75691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75692       };
75693     } catch (Dali::DaliException e) {
75694       {
75695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75696       };
75697     } catch (...) {
75698       {
75699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75700       };
75701     }
75702   }
75703
75704   jresult = (void *)result;
75705   return jresult;
75706 }
75707
75708
75709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75710   void * jresult ;
75711   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75712   Dali::Toolkit::ItemView *arg2 = 0 ;
75713   Dali::Toolkit::ItemView *result = 0 ;
75714
75715   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75716   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75717   if (!arg2) {
75718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75719     return 0;
75720   }
75721   {
75722     try {
75723       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75724     } catch (std::out_of_range& e) {
75725       {
75726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75727       };
75728     } catch (std::exception& e) {
75729       {
75730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75731       };
75732     } catch (Dali::DaliException e) {
75733       {
75734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75735       };
75736     } catch (...) {
75737       {
75738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75739       };
75740     }
75741   }
75742
75743   jresult = (void *)result;
75744   return jresult;
75745 }
75746
75747
75748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75749   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75750
75751   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75752   {
75753     try {
75754       delete arg1;
75755     } catch (std::out_of_range& e) {
75756       {
75757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75758       };
75759     } catch (std::exception& e) {
75760       {
75761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75762       };
75763     } catch (Dali::DaliException e) {
75764       {
75765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75766       };
75767     } catch (...) {
75768       {
75769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75770       };
75771     }
75772   }
75773
75774 }
75775
75776
75777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
75778   void * jresult ;
75779   Dali::Toolkit::ItemFactory *arg1 = 0 ;
75780   Dali::Toolkit::ItemView result;
75781
75782   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75783   if (!arg1) {
75784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
75785     return 0;
75786   }
75787   {
75788     try {
75789       result = Dali::Toolkit::ItemView::New(*arg1);
75790     } catch (std::out_of_range& e) {
75791       {
75792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75793       };
75794     } catch (std::exception& e) {
75795       {
75796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75797       };
75798     } catch (Dali::DaliException e) {
75799       {
75800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75801       };
75802     } catch (...) {
75803       {
75804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75805       };
75806     }
75807   }
75808
75809   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75810   return jresult;
75811 }
75812
75813
75814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
75815   void * jresult ;
75816   Dali::BaseHandle arg1 ;
75817   Dali::BaseHandle *argp1 ;
75818   Dali::Toolkit::ItemView result;
75819
75820   argp1 = (Dali::BaseHandle *)jarg1;
75821   if (!argp1) {
75822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75823     return 0;
75824   }
75825   arg1 = *argp1;
75826   {
75827     try {
75828       result = Dali::Toolkit::ItemView::DownCast(arg1);
75829     } catch (std::out_of_range& e) {
75830       {
75831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75832       };
75833     } catch (std::exception& e) {
75834       {
75835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75836       };
75837     } catch (Dali::DaliException e) {
75838       {
75839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75840       };
75841     } catch (...) {
75842       {
75843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75844       };
75845     }
75846   }
75847
75848   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75849   return jresult;
75850 }
75851
75852
75853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75854   unsigned int jresult ;
75855   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75856   unsigned int result;
75857
75858   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75859   {
75860     try {
75861       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75862     } catch (std::out_of_range& e) {
75863       {
75864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75865       };
75866     } catch (std::exception& e) {
75867       {
75868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75869       };
75870     } catch (Dali::DaliException e) {
75871       {
75872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75873       };
75874     } catch (...) {
75875       {
75876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75877       };
75878     }
75879   }
75880
75881   jresult = result;
75882   return jresult;
75883 }
75884
75885
75886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75887   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75888   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75889
75890   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75891   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75892   if (!arg2) {
75893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75894     return ;
75895   }
75896   {
75897     try {
75898       (arg1)->AddLayout(*arg2);
75899     } catch (std::out_of_range& e) {
75900       {
75901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75902       };
75903     } catch (std::exception& e) {
75904       {
75905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75906       };
75907     } catch (Dali::DaliException e) {
75908       {
75909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75910       };
75911     } catch (...) {
75912       {
75913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75914       };
75915     }
75916   }
75917
75918 }
75919
75920
75921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75922   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75923   unsigned int arg2 ;
75924
75925   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75926   arg2 = (unsigned int)jarg2;
75927   {
75928     try {
75929       (arg1)->RemoveLayout(arg2);
75930     } catch (std::out_of_range& e) {
75931       {
75932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75933       };
75934     } catch (std::exception& e) {
75935       {
75936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75937       };
75938     } catch (Dali::DaliException e) {
75939       {
75940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75941       };
75942     } catch (...) {
75943       {
75944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75945       };
75946     }
75947   }
75948
75949 }
75950
75951
75952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75953   void * jresult ;
75954   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75955   unsigned int arg2 ;
75956   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75957
75958   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75959   arg2 = (unsigned int)jarg2;
75960   {
75961     try {
75962       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75963     } catch (std::out_of_range& e) {
75964       {
75965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75966       };
75967     } catch (std::exception& e) {
75968       {
75969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75970       };
75971     } catch (Dali::DaliException e) {
75972       {
75973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75974       };
75975     } catch (...) {
75976       {
75977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75978       };
75979     }
75980   }
75981
75982   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75983   return jresult;
75984 }
75985
75986
75987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75988   void * jresult ;
75989   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75990   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75991
75992   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75993   {
75994     try {
75995       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75996     } catch (std::out_of_range& e) {
75997       {
75998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75999       };
76000     } catch (std::exception& e) {
76001       {
76002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76003       };
76004     } catch (Dali::DaliException e) {
76005       {
76006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76007       };
76008     } catch (...) {
76009       {
76010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76011       };
76012     }
76013   }
76014
76015   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
76016   return jresult;
76017 }
76018
76019
76020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
76021   float jresult ;
76022   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76023   Dali::Toolkit::ItemId arg2 ;
76024   float result;
76025
76026   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76027   arg2 = (Dali::Toolkit::ItemId)jarg2;
76028   {
76029     try {
76030       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
76031     } catch (std::out_of_range& e) {
76032       {
76033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76034       };
76035     } catch (std::exception& e) {
76036       {
76037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76038       };
76039     } catch (Dali::DaliException e) {
76040       {
76041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76042       };
76043     } catch (...) {
76044       {
76045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76046       };
76047     }
76048   }
76049
76050   jresult = result;
76051   return jresult;
76052 }
76053
76054
76055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76056   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76057   unsigned int arg2 ;
76058   Dali::Vector3 arg3 ;
76059   float arg4 ;
76060   Dali::Vector3 *argp3 ;
76061
76062   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76063   arg2 = (unsigned int)jarg2;
76064   argp3 = (Dali::Vector3 *)jarg3;
76065   if (!argp3) {
76066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76067     return ;
76068   }
76069   arg3 = *argp3;
76070   arg4 = (float)jarg4;
76071   {
76072     try {
76073       (arg1)->ActivateLayout(arg2,arg3,arg4);
76074     } catch (std::out_of_range& e) {
76075       {
76076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76077       };
76078     } catch (std::exception& e) {
76079       {
76080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76081       };
76082     } catch (Dali::DaliException e) {
76083       {
76084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76085       };
76086     } catch (...) {
76087       {
76088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76089       };
76090     }
76091   }
76092
76093 }
76094
76095
76096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76097   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76098
76099   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76100   {
76101     try {
76102       (arg1)->DeactivateCurrentLayout();
76103     } catch (std::out_of_range& e) {
76104       {
76105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76106       };
76107     } catch (std::exception& e) {
76108       {
76109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76110       };
76111     } catch (Dali::DaliException e) {
76112       {
76113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76114       };
76115     } catch (...) {
76116       {
76117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76118       };
76119     }
76120   }
76121
76122 }
76123
76124
76125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76126   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76127   float arg2 ;
76128
76129   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76130   arg2 = (float)jarg2;
76131   {
76132     try {
76133       (arg1)->SetMinimumSwipeSpeed(arg2);
76134     } catch (std::out_of_range& e) {
76135       {
76136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76137       };
76138     } catch (std::exception& e) {
76139       {
76140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76141       };
76142     } catch (Dali::DaliException e) {
76143       {
76144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76145       };
76146     } catch (...) {
76147       {
76148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76149       };
76150     }
76151   }
76152
76153 }
76154
76155
76156 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76157   float jresult ;
76158   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76159   float result;
76160
76161   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76162   {
76163     try {
76164       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76165     } catch (std::out_of_range& e) {
76166       {
76167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76168       };
76169     } catch (std::exception& e) {
76170       {
76171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76172       };
76173     } catch (Dali::DaliException e) {
76174       {
76175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76176       };
76177     } catch (...) {
76178       {
76179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76180       };
76181     }
76182   }
76183
76184   jresult = result;
76185   return jresult;
76186 }
76187
76188
76189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76190   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76191   float arg2 ;
76192
76193   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76194   arg2 = (float)jarg2;
76195   {
76196     try {
76197       (arg1)->SetMinimumSwipeDistance(arg2);
76198     } catch (std::out_of_range& e) {
76199       {
76200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76201       };
76202     } catch (std::exception& e) {
76203       {
76204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76205       };
76206     } catch (Dali::DaliException e) {
76207       {
76208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76209       };
76210     } catch (...) {
76211       {
76212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76213       };
76214     }
76215   }
76216
76217 }
76218
76219
76220 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76221   float jresult ;
76222   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76223   float result;
76224
76225   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76226   {
76227     try {
76228       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76229     } catch (std::out_of_range& e) {
76230       {
76231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76232       };
76233     } catch (std::exception& e) {
76234       {
76235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76236       };
76237     } catch (Dali::DaliException e) {
76238       {
76239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76240       };
76241     } catch (...) {
76242       {
76243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76244       };
76245     }
76246   }
76247
76248   jresult = result;
76249   return jresult;
76250 }
76251
76252
76253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76254   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76255   float arg2 ;
76256
76257   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76258   arg2 = (float)jarg2;
76259   {
76260     try {
76261       (arg1)->SetWheelScrollDistanceStep(arg2);
76262     } catch (std::out_of_range& e) {
76263       {
76264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76265       };
76266     } catch (std::exception& e) {
76267       {
76268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76269       };
76270     } catch (Dali::DaliException e) {
76271       {
76272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76273       };
76274     } catch (...) {
76275       {
76276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76277       };
76278     }
76279   }
76280
76281 }
76282
76283
76284 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76285   float jresult ;
76286   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76287   float result;
76288
76289   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76290   {
76291     try {
76292       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76293     } catch (std::out_of_range& e) {
76294       {
76295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76296       };
76297     } catch (std::exception& e) {
76298       {
76299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76300       };
76301     } catch (Dali::DaliException e) {
76302       {
76303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76304       };
76305     } catch (...) {
76306       {
76307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76308       };
76309     }
76310   }
76311
76312   jresult = result;
76313   return jresult;
76314 }
76315
76316
76317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76318   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76319   bool arg2 ;
76320
76321   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76322   arg2 = jarg2 ? true : false;
76323   {
76324     try {
76325       (arg1)->SetAnchoring(arg2);
76326     } catch (std::out_of_range& e) {
76327       {
76328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76329       };
76330     } catch (std::exception& e) {
76331       {
76332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76333       };
76334     } catch (Dali::DaliException e) {
76335       {
76336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76337       };
76338     } catch (...) {
76339       {
76340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76341       };
76342     }
76343   }
76344
76345 }
76346
76347 //// ========================= end of part 3 =============================
76348
76349 //// ========================== start part 4 ===============================
76350
76351
76352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76353   unsigned int jresult ;
76354   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76355   bool result;
76356
76357   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76358   {
76359     try {
76360       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76361     } catch (std::out_of_range& e) {
76362       {
76363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76364       };
76365     } catch (std::exception& e) {
76366       {
76367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76368       };
76369     } catch (Dali::DaliException e) {
76370       {
76371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76372       };
76373     } catch (...) {
76374       {
76375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76376       };
76377     }
76378   }
76379
76380   jresult = result;
76381   return jresult;
76382 }
76383
76384
76385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76386   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76387   float arg2 ;
76388
76389   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76390   arg2 = (float)jarg2;
76391   {
76392     try {
76393       (arg1)->SetAnchoringDuration(arg2);
76394     } catch (std::out_of_range& e) {
76395       {
76396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76397       };
76398     } catch (std::exception& e) {
76399       {
76400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76401       };
76402     } catch (Dali::DaliException e) {
76403       {
76404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76405       };
76406     } catch (...) {
76407       {
76408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76409       };
76410     }
76411   }
76412
76413 }
76414
76415
76416 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76417   float jresult ;
76418   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76419   float result;
76420
76421   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76422   {
76423     try {
76424       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76425     } catch (std::out_of_range& e) {
76426       {
76427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76428       };
76429     } catch (std::exception& e) {
76430       {
76431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76432       };
76433     } catch (Dali::DaliException e) {
76434       {
76435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76436       };
76437     } catch (...) {
76438       {
76439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76440       };
76441     }
76442   }
76443
76444   jresult = result;
76445   return jresult;
76446 }
76447
76448
76449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76450   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76451   Dali::Toolkit::ItemId arg2 ;
76452   float arg3 ;
76453
76454   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76455   arg2 = (Dali::Toolkit::ItemId)jarg2;
76456   arg3 = (float)jarg3;
76457   {
76458     try {
76459       (arg1)->ScrollToItem(arg2,arg3);
76460     } catch (std::out_of_range& e) {
76461       {
76462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76463       };
76464     } catch (std::exception& e) {
76465       {
76466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76467       };
76468     } catch (Dali::DaliException e) {
76469       {
76470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76471       };
76472     } catch (...) {
76473       {
76474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76475       };
76476     }
76477   }
76478
76479 }
76480
76481
76482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76483   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76484   float arg2 ;
76485
76486   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76487   arg2 = (float)jarg2;
76488   {
76489     try {
76490       (arg1)->SetRefreshInterval(arg2);
76491     } catch (std::out_of_range& e) {
76492       {
76493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76494       };
76495     } catch (std::exception& e) {
76496       {
76497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76498       };
76499     } catch (Dali::DaliException e) {
76500       {
76501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76502       };
76503     } catch (...) {
76504       {
76505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76506       };
76507     }
76508   }
76509
76510 }
76511
76512
76513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76514   float jresult ;
76515   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76516   float result;
76517
76518   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76519   {
76520     try {
76521       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76522     } catch (std::out_of_range& e) {
76523       {
76524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76525       };
76526     } catch (std::exception& e) {
76527       {
76528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76529       };
76530     } catch (Dali::DaliException e) {
76531       {
76532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76533       };
76534     } catch (...) {
76535       {
76536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76537       };
76538     }
76539   }
76540
76541   jresult = result;
76542   return jresult;
76543 }
76544
76545
76546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76547   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76548
76549   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76550   {
76551     try {
76552       (arg1)->Refresh();
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_GetItem(void * jarg1, unsigned int jarg2) {
76576   void * jresult ;
76577   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76578   Dali::Toolkit::ItemId arg2 ;
76579   Dali::Actor result;
76580
76581   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76582   arg2 = (Dali::Toolkit::ItemId)jarg2;
76583   {
76584     try {
76585       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76586     } catch (std::out_of_range& e) {
76587       {
76588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76589       };
76590     } catch (std::exception& e) {
76591       {
76592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76593       };
76594     } catch (Dali::DaliException e) {
76595       {
76596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76597       };
76598     } catch (...) {
76599       {
76600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76601       };
76602     }
76603   }
76604
76605   jresult = new Dali::Actor((const Dali::Actor &)result);
76606   return jresult;
76607 }
76608
76609
76610 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76611   unsigned int jresult ;
76612   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76613   Dali::Actor arg2 ;
76614   Dali::Actor *argp2 ;
76615   Dali::Toolkit::ItemId result;
76616
76617   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76618   argp2 = (Dali::Actor *)jarg2;
76619   if (!argp2) {
76620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76621     return 0;
76622   }
76623   arg2 = *argp2;
76624   {
76625     try {
76626       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76627     } catch (std::out_of_range& e) {
76628       {
76629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76630       };
76631     } catch (std::exception& e) {
76632       {
76633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76634       };
76635     } catch (Dali::DaliException e) {
76636       {
76637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76638       };
76639     } catch (...) {
76640       {
76641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76642       };
76643     }
76644   }
76645
76646   jresult = result;
76647   return jresult;
76648 }
76649
76650
76651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76652   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76653   Dali::Toolkit::Item arg2 ;
76654   float arg3 ;
76655   Dali::Toolkit::Item *argp2 ;
76656
76657   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76658   argp2 = (Dali::Toolkit::Item *)jarg2;
76659   if (!argp2) {
76660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76661     return ;
76662   }
76663   arg2 = *argp2;
76664   arg3 = (float)jarg3;
76665   {
76666     try {
76667       (arg1)->InsertItem(arg2,arg3);
76668     } catch (std::out_of_range& e) {
76669       {
76670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76671       };
76672     } catch (std::exception& e) {
76673       {
76674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76675       };
76676     } catch (Dali::DaliException e) {
76677       {
76678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76679       };
76680     } catch (...) {
76681       {
76682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76683       };
76684     }
76685   }
76686
76687 }
76688
76689
76690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76691   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76692   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76693   float arg3 ;
76694
76695   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76696   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76697   if (!arg2) {
76698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76699     return ;
76700   }
76701   arg3 = (float)jarg3;
76702   {
76703     try {
76704       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76705     } catch (std::out_of_range& e) {
76706       {
76707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76708       };
76709     } catch (std::exception& e) {
76710       {
76711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76712       };
76713     } catch (Dali::DaliException e) {
76714       {
76715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76716       };
76717     } catch (...) {
76718       {
76719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76720       };
76721     }
76722   }
76723
76724 }
76725
76726
76727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76728   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76729   Dali::Toolkit::ItemId arg2 ;
76730   float arg3 ;
76731
76732   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76733   arg2 = (Dali::Toolkit::ItemId)jarg2;
76734   arg3 = (float)jarg3;
76735   {
76736     try {
76737       (arg1)->RemoveItem(arg2,arg3);
76738     } catch (std::out_of_range& e) {
76739       {
76740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76741       };
76742     } catch (std::exception& e) {
76743       {
76744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76745       };
76746     } catch (Dali::DaliException e) {
76747       {
76748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76749       };
76750     } catch (...) {
76751       {
76752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76753       };
76754     }
76755   }
76756
76757 }
76758
76759
76760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
76761   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76762   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
76763   float arg3 ;
76764
76765   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76766   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
76767   if (!arg2) {
76768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
76769     return ;
76770   }
76771   arg3 = (float)jarg3;
76772   {
76773     try {
76774       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
76775     } catch (std::out_of_range& e) {
76776       {
76777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76778       };
76779     } catch (std::exception& e) {
76780       {
76781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76782       };
76783     } catch (Dali::DaliException e) {
76784       {
76785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76786       };
76787     } catch (...) {
76788       {
76789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76790       };
76791     }
76792   }
76793
76794 }
76795
76796
76797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
76798   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76799   Dali::Toolkit::Item arg2 ;
76800   float arg3 ;
76801   Dali::Toolkit::Item *argp2 ;
76802
76803   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76804   argp2 = (Dali::Toolkit::Item *)jarg2;
76805   if (!argp2) {
76806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76807     return ;
76808   }
76809   arg2 = *argp2;
76810   arg3 = (float)jarg3;
76811   {
76812     try {
76813       (arg1)->ReplaceItem(arg2,arg3);
76814     } catch (std::out_of_range& e) {
76815       {
76816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76817       };
76818     } catch (std::exception& e) {
76819       {
76820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76821       };
76822     } catch (Dali::DaliException e) {
76823       {
76824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76825       };
76826     } catch (...) {
76827       {
76828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76829       };
76830     }
76831   }
76832
76833 }
76834
76835
76836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
76837   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76838   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76839   float arg3 ;
76840
76841   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76842   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76843   if (!arg2) {
76844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76845     return ;
76846   }
76847   arg3 = (float)jarg3;
76848   {
76849     try {
76850       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76851     } catch (std::out_of_range& e) {
76852       {
76853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76854       };
76855     } catch (std::exception& e) {
76856       {
76857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76858       };
76859     } catch (Dali::DaliException e) {
76860       {
76861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76862       };
76863     } catch (...) {
76864       {
76865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76866       };
76867     }
76868   }
76869
76870 }
76871
76872
76873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76874   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76875   Dali::Vector3 *arg2 = 0 ;
76876
76877   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76878   arg2 = (Dali::Vector3 *)jarg2;
76879   if (!arg2) {
76880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76881     return ;
76882   }
76883   {
76884     try {
76885       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76886     } catch (std::out_of_range& e) {
76887       {
76888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76889       };
76890     } catch (std::exception& e) {
76891       {
76892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76893       };
76894     } catch (Dali::DaliException e) {
76895       {
76896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76897       };
76898     } catch (...) {
76899       {
76900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76901       };
76902     }
76903   }
76904
76905 }
76906
76907
76908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76909   void * jresult ;
76910   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76911   Dali::Vector3 result;
76912
76913   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76914   {
76915     try {
76916       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76917     } catch (std::out_of_range& e) {
76918       {
76919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76920       };
76921     } catch (std::exception& e) {
76922       {
76923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76924       };
76925     } catch (Dali::DaliException e) {
76926       {
76927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76928       };
76929     } catch (...) {
76930       {
76931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76932       };
76933     }
76934   }
76935
76936   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76937   return jresult;
76938 }
76939
76940
76941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76942   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76943   Dali::Vector3 *arg2 = 0 ;
76944
76945   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76946   arg2 = (Dali::Vector3 *)jarg2;
76947   if (!arg2) {
76948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76949     return ;
76950   }
76951   {
76952     try {
76953       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76954     } catch (std::out_of_range& e) {
76955       {
76956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76957       };
76958     } catch (std::exception& e) {
76959       {
76960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76961       };
76962     } catch (Dali::DaliException e) {
76963       {
76964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76965       };
76966     } catch (...) {
76967       {
76968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76969       };
76970     }
76971   }
76972
76973 }
76974
76975
76976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76977   void * jresult ;
76978   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76979   Dali::Vector3 result;
76980
76981   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76982   {
76983     try {
76984       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76985     } catch (std::out_of_range& e) {
76986       {
76987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76988       };
76989     } catch (std::exception& e) {
76990       {
76991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76992       };
76993     } catch (Dali::DaliException e) {
76994       {
76995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76996       };
76997     } catch (...) {
76998       {
76999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77000       };
77001     }
77002   }
77003
77004   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
77005   return jresult;
77006 }
77007
77008
77009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
77010   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77011   Dali::Toolkit::ItemRange *arg2 = 0 ;
77012
77013   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77014   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
77015   if (!arg2) {
77016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
77017     return ;
77018   }
77019   {
77020     try {
77021       (arg1)->GetItemsRange(*arg2);
77022     } catch (std::out_of_range& e) {
77023       {
77024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77025       };
77026     } catch (std::exception& e) {
77027       {
77028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77029       };
77030     } catch (Dali::DaliException e) {
77031       {
77032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77033       };
77034     } catch (...) {
77035       {
77036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77037       };
77038     }
77039   }
77040
77041 }
77042
77043
77044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77045   void * jresult ;
77046   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77047   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77048
77049   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77050   {
77051     try {
77052       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77053     } catch (std::out_of_range& e) {
77054       {
77055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77056       };
77057     } catch (std::exception& e) {
77058       {
77059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77060       };
77061     } catch (Dali::DaliException e) {
77062       {
77063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77064       };
77065     } catch (...) {
77066       {
77067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77068       };
77069     }
77070   }
77071
77072   jresult = (void *)result;
77073   return jresult;
77074 }
77075
77076
77077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77078   Dali::Vector3 *arg1 = 0 ;
77079   PropertyInputContainer *arg2 = 0 ;
77080
77081   arg1 = (Dali::Vector3 *)jarg1;
77082   if (!arg1) {
77083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77084     return ;
77085   }
77086   arg2 = (PropertyInputContainer *)jarg2;
77087   if (!arg2) {
77088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77089     return ;
77090   }
77091   {
77092     try {
77093       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77094     } catch (std::out_of_range& e) {
77095       {
77096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77097       };
77098     } catch (std::exception& e) {
77099       {
77100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77101       };
77102     } catch (Dali::DaliException e) {
77103       {
77104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77105       };
77106     } catch (...) {
77107       {
77108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77109       };
77110     }
77111   }
77112
77113 }
77114
77115
77116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77117   Dali::Vector3 *arg1 = 0 ;
77118   PropertyInputContainer *arg2 = 0 ;
77119
77120   arg1 = (Dali::Vector3 *)jarg1;
77121   if (!arg1) {
77122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77123     return ;
77124   }
77125   arg2 = (PropertyInputContainer *)jarg2;
77126   if (!arg2) {
77127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77128     return ;
77129   }
77130   {
77131     try {
77132       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77133     } catch (std::out_of_range& e) {
77134       {
77135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77136       };
77137     } catch (std::exception& e) {
77138       {
77139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77140       };
77141     } catch (Dali::DaliException e) {
77142       {
77143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77144       };
77145     } catch (...) {
77146       {
77147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77148       };
77149     }
77150   }
77151
77152 }
77153
77154
77155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77156   void * jresult ;
77157   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77158
77159   {
77160     try {
77161       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77162     } catch (std::out_of_range& e) {
77163       {
77164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77165       };
77166     } catch (std::exception& e) {
77167       {
77168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77169       };
77170     } catch (Dali::DaliException e) {
77171       {
77172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77173       };
77174     } catch (...) {
77175       {
77176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77177       };
77178     }
77179   }
77180
77181   jresult = (void *)result;
77182   return jresult;
77183 }
77184
77185
77186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77187   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77188
77189   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77190   {
77191     try {
77192       delete arg1;
77193     } catch (std::out_of_range& e) {
77194       {
77195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77196       };
77197     } catch (std::exception& e) {
77198       {
77199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77200       };
77201     } catch (Dali::DaliException e) {
77202       {
77203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77204       };
77205     } catch (...) {
77206       {
77207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77208       };
77209     }
77210   }
77211
77212 }
77213
77214
77215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77216   void * jresult ;
77217   Dali::Path arg1 ;
77218   Dali::Vector3 *arg2 = 0 ;
77219   Dali::Property::Index arg3 ;
77220   Dali::Vector3 *arg4 = 0 ;
77221   unsigned int arg5 ;
77222   Dali::Path *argp1 ;
77223   Dali::Toolkit::ScrollViewPagePathEffect result;
77224
77225   argp1 = (Dali::Path *)jarg1;
77226   if (!argp1) {
77227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77228     return 0;
77229   }
77230   arg1 = *argp1;
77231   arg2 = (Dali::Vector3 *)jarg2;
77232   if (!arg2) {
77233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77234     return 0;
77235   }
77236   arg3 = (Dali::Property::Index)jarg3;
77237   arg4 = (Dali::Vector3 *)jarg4;
77238   if (!arg4) {
77239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77240     return 0;
77241   }
77242   arg5 = (unsigned int)jarg5;
77243   {
77244     try {
77245       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77246     } catch (std::out_of_range& e) {
77247       {
77248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77249       };
77250     } catch (std::exception& e) {
77251       {
77252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77253       };
77254     } catch (Dali::DaliException e) {
77255       {
77256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77257       };
77258     } catch (...) {
77259       {
77260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77261       };
77262     }
77263   }
77264
77265   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77266   return jresult;
77267 }
77268
77269
77270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77271   void * jresult ;
77272   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77273
77274   {
77275     try {
77276       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77277     } catch (std::out_of_range& e) {
77278       {
77279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77280       };
77281     } catch (std::exception& e) {
77282       {
77283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77284       };
77285     } catch (Dali::DaliException e) {
77286       {
77287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77288       };
77289     } catch (...) {
77290       {
77291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77292       };
77293     }
77294   }
77295
77296   jresult = (void *)result;
77297   return jresult;
77298 }
77299
77300
77301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77302   void * jresult ;
77303   Dali::BaseHandle arg1 ;
77304   Dali::BaseHandle *argp1 ;
77305   Dali::Toolkit::ScrollViewPagePathEffect result;
77306
77307   argp1 = (Dali::BaseHandle *)jarg1;
77308   if (!argp1) {
77309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77310     return 0;
77311   }
77312   arg1 = *argp1;
77313   {
77314     try {
77315       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77316     } catch (std::out_of_range& e) {
77317       {
77318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77319       };
77320     } catch (std::exception& e) {
77321       {
77322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77323       };
77324     } catch (Dali::DaliException e) {
77325       {
77326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77327       };
77328     } catch (...) {
77329       {
77330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77331       };
77332     }
77333   }
77334
77335   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77336   return jresult;
77337 }
77338
77339
77340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77341   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77342   Dali::Actor arg2 ;
77343   unsigned int arg3 ;
77344   Dali::Actor *argp2 ;
77345
77346   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77347   argp2 = (Dali::Actor *)jarg2;
77348   if (!argp2) {
77349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77350     return ;
77351   }
77352   arg2 = *argp2;
77353   arg3 = (unsigned int)jarg3;
77354   {
77355     try {
77356       (arg1)->ApplyToPage(arg2,arg3);
77357     } catch (std::out_of_range& e) {
77358       {
77359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77360       };
77361     } catch (std::exception& e) {
77362       {
77363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77364       };
77365     } catch (Dali::DaliException e) {
77366       {
77367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77368       };
77369     } catch (...) {
77370       {
77371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77372       };
77373     }
77374   }
77375
77376 }
77377
77378
77379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77380   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77381
77382   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77383   {
77384     try {
77385       delete arg1;
77386     } catch (std::out_of_range& e) {
77387       {
77388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77389       };
77390     } catch (std::exception& e) {
77391       {
77392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77393       };
77394     } catch (Dali::DaliException e) {
77395       {
77396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77397       };
77398     } catch (...) {
77399       {
77400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77401       };
77402     }
77403   }
77404
77405 }
77406
77407
77408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77409   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77410   Dali::Toolkit::ClampState arg2 ;
77411
77412   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77413   arg2 = (Dali::Toolkit::ClampState)jarg2;
77414   if (arg1) (arg1)->x = arg2;
77415 }
77416
77417
77418 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77419   int jresult ;
77420   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77421   Dali::Toolkit::ClampState result;
77422
77423   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77424   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77425   jresult = (int)result;
77426   return jresult;
77427 }
77428
77429
77430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77431   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77432   Dali::Toolkit::ClampState arg2 ;
77433
77434   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77435   arg2 = (Dali::Toolkit::ClampState)jarg2;
77436   if (arg1) (arg1)->y = arg2;
77437 }
77438
77439
77440 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77441   int jresult ;
77442   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77443   Dali::Toolkit::ClampState result;
77444
77445   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77446   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77447   jresult = (int)result;
77448   return jresult;
77449 }
77450
77451
77452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77453   void * jresult ;
77454   Dali::Toolkit::ClampState2D *result = 0 ;
77455
77456   {
77457     try {
77458       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77459     } catch (std::out_of_range& e) {
77460       {
77461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77462       };
77463     } catch (std::exception& e) {
77464       {
77465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77466       };
77467     } catch (Dali::DaliException e) {
77468       {
77469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77470       };
77471     } catch (...) {
77472       {
77473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77474       };
77475     }
77476   }
77477
77478   jresult = (void *)result;
77479   return jresult;
77480 }
77481
77482
77483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77484   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77485
77486   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77487   {
77488     try {
77489       delete arg1;
77490     } catch (std::out_of_range& e) {
77491       {
77492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77493       };
77494     } catch (std::exception& e) {
77495       {
77496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77497       };
77498     } catch (Dali::DaliException e) {
77499       {
77500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77501       };
77502     } catch (...) {
77503       {
77504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77505       };
77506     }
77507   }
77508
77509 }
77510
77511
77512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77513   void * jresult ;
77514   float arg1 ;
77515   float arg2 ;
77516   bool arg3 ;
77517   Dali::Toolkit::RulerDomain *result = 0 ;
77518
77519   arg1 = (float)jarg1;
77520   arg2 = (float)jarg2;
77521   arg3 = jarg3 ? true : false;
77522   {
77523     try {
77524       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77525     } catch (std::out_of_range& e) {
77526       {
77527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77528       };
77529     } catch (std::exception& e) {
77530       {
77531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77532       };
77533     } catch (Dali::DaliException e) {
77534       {
77535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77536       };
77537     } catch (...) {
77538       {
77539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77540       };
77541     }
77542   }
77543
77544   jresult = (void *)result;
77545   return jresult;
77546 }
77547
77548
77549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77550   void * jresult ;
77551   float arg1 ;
77552   float arg2 ;
77553   Dali::Toolkit::RulerDomain *result = 0 ;
77554
77555   arg1 = (float)jarg1;
77556   arg2 = (float)jarg2;
77557   {
77558     try {
77559       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77560     } catch (std::out_of_range& e) {
77561       {
77562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77563       };
77564     } catch (std::exception& e) {
77565       {
77566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77567       };
77568     } catch (Dali::DaliException e) {
77569       {
77570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77571       };
77572     } catch (...) {
77573       {
77574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77575       };
77576     }
77577   }
77578
77579   jresult = (void *)result;
77580   return jresult;
77581 }
77582
77583
77584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77585   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77586   float arg2 ;
77587
77588   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77589   arg2 = (float)jarg2;
77590   if (arg1) (arg1)->min = arg2;
77591 }
77592
77593
77594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77595   float jresult ;
77596   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77597   float result;
77598
77599   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77600   result = (float) ((arg1)->min);
77601   jresult = result;
77602   return jresult;
77603 }
77604
77605
77606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77607   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77608   float arg2 ;
77609
77610   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77611   arg2 = (float)jarg2;
77612   if (arg1) (arg1)->max = arg2;
77613 }
77614
77615
77616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77617   float jresult ;
77618   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77619   float result;
77620
77621   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77622   result = (float) ((arg1)->max);
77623   jresult = result;
77624   return jresult;
77625 }
77626
77627
77628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77629   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77630   bool arg2 ;
77631
77632   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77633   arg2 = jarg2 ? true : false;
77634   if (arg1) (arg1)->enabled = arg2;
77635 }
77636
77637
77638 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77639   unsigned int jresult ;
77640   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77641   bool result;
77642
77643   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77644   result = (bool) ((arg1)->enabled);
77645   jresult = result;
77646   return jresult;
77647 }
77648
77649
77650 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77651   float jresult ;
77652   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77653   float arg2 ;
77654   float arg3 ;
77655   float arg4 ;
77656   float result;
77657
77658   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77659   arg2 = (float)jarg2;
77660   arg3 = (float)jarg3;
77661   arg4 = (float)jarg4;
77662   {
77663     try {
77664       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77665     } catch (std::out_of_range& e) {
77666       {
77667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77668       };
77669     } catch (std::exception& e) {
77670       {
77671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77672       };
77673     } catch (Dali::DaliException e) {
77674       {
77675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77676       };
77677     } catch (...) {
77678       {
77679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77680       };
77681     }
77682   }
77683
77684   jresult = result;
77685   return jresult;
77686 }
77687
77688
77689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77690   float jresult ;
77691   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77692   float arg2 ;
77693   float arg3 ;
77694   float result;
77695
77696   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77697   arg2 = (float)jarg2;
77698   arg3 = (float)jarg3;
77699   {
77700     try {
77701       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77702     } catch (std::out_of_range& e) {
77703       {
77704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77705       };
77706     } catch (std::exception& e) {
77707       {
77708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77709       };
77710     } catch (Dali::DaliException e) {
77711       {
77712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77713       };
77714     } catch (...) {
77715       {
77716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77717       };
77718     }
77719   }
77720
77721   jresult = result;
77722   return jresult;
77723 }
77724
77725
77726 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77727   float jresult ;
77728   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77729   float arg2 ;
77730   float result;
77731
77732   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77733   arg2 = (float)jarg2;
77734   {
77735     try {
77736       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77737     } catch (std::out_of_range& e) {
77738       {
77739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77740       };
77741     } catch (std::exception& e) {
77742       {
77743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77744       };
77745     } catch (Dali::DaliException e) {
77746       {
77747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77748       };
77749     } catch (...) {
77750       {
77751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77752       };
77753     }
77754   }
77755
77756   jresult = result;
77757   return jresult;
77758 }
77759
77760
77761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77762   float jresult ;
77763   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77764   float arg2 ;
77765   float arg3 ;
77766   float arg4 ;
77767   Dali::Toolkit::ClampState *arg5 = 0 ;
77768   float result;
77769
77770   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77771   arg2 = (float)jarg2;
77772   arg3 = (float)jarg3;
77773   arg4 = (float)jarg4;
77774   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77775   if (!arg5) {
77776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77777     return 0;
77778   }
77779   {
77780     try {
77781       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77782     } catch (std::out_of_range& e) {
77783       {
77784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77785       };
77786     } catch (std::exception& e) {
77787       {
77788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77789       };
77790     } catch (Dali::DaliException e) {
77791       {
77792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77793       };
77794     } catch (...) {
77795       {
77796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77797       };
77798     }
77799   }
77800
77801   jresult = result;
77802   return jresult;
77803 }
77804
77805
77806 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
77807   float jresult ;
77808   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77809   float result;
77810
77811   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77812   {
77813     try {
77814       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
77815     } catch (std::out_of_range& e) {
77816       {
77817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77818       };
77819     } catch (std::exception& e) {
77820       {
77821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77822       };
77823     } catch (Dali::DaliException e) {
77824       {
77825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77826       };
77827     } catch (...) {
77828       {
77829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77830       };
77831     }
77832   }
77833
77834   jresult = result;
77835   return jresult;
77836 }
77837
77838
77839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
77840   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77841
77842   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77843   {
77844     try {
77845       delete arg1;
77846     } catch (std::out_of_range& e) {
77847       {
77848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77849       };
77850     } catch (std::exception& e) {
77851       {
77852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77853       };
77854     } catch (Dali::DaliException e) {
77855       {
77856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77857       };
77858     } catch (...) {
77859       {
77860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77861       };
77862     }
77863   }
77864
77865 }
77866
77867
77868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77869   float jresult ;
77870   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77871   float arg2 ;
77872   float arg3 ;
77873   float result;
77874
77875   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77876   arg2 = (float)jarg2;
77877   arg3 = (float)jarg3;
77878   {
77879     try {
77880       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77881     } catch (std::out_of_range& e) {
77882       {
77883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77884       };
77885     } catch (std::exception& e) {
77886       {
77887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77888       };
77889     } catch (Dali::DaliException e) {
77890       {
77891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77892       };
77893     } catch (...) {
77894       {
77895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77896       };
77897     }
77898   }
77899
77900   jresult = result;
77901   return jresult;
77902 }
77903
77904
77905 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77906   float jresult ;
77907   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77908   float arg2 ;
77909   float result;
77910
77911   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77912   arg2 = (float)jarg2;
77913   {
77914     try {
77915       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77916     } catch (std::out_of_range& e) {
77917       {
77918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77919       };
77920     } catch (std::exception& e) {
77921       {
77922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77923       };
77924     } catch (Dali::DaliException e) {
77925       {
77926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77927       };
77928     } catch (...) {
77929       {
77930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77931       };
77932     }
77933   }
77934
77935   jresult = result;
77936   return jresult;
77937 }
77938
77939
77940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77941   float jresult ;
77942   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77943   unsigned int arg2 ;
77944   unsigned int *arg3 = 0 ;
77945   bool arg4 ;
77946   float result;
77947
77948   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77949   arg2 = (unsigned int)jarg2;
77950   arg3 = (unsigned int *)jarg3;
77951   arg4 = jarg4 ? true : false;
77952   {
77953     try {
77954       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77955     } catch (std::out_of_range& e) {
77956       {
77957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77958       };
77959     } catch (std::exception& e) {
77960       {
77961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77962       };
77963     } catch (Dali::DaliException e) {
77964       {
77965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77966       };
77967     } catch (...) {
77968       {
77969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77970       };
77971     }
77972   }
77973
77974   jresult = result;
77975   return jresult;
77976 }
77977
77978
77979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77980   unsigned int jresult ;
77981   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77982   float arg2 ;
77983   bool arg3 ;
77984   unsigned int result;
77985
77986   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77987   arg2 = (float)jarg2;
77988   arg3 = jarg3 ? true : false;
77989   {
77990     try {
77991       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77992     } catch (std::out_of_range& e) {
77993       {
77994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77995       };
77996     } catch (std::exception& e) {
77997       {
77998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77999       };
78000     } catch (Dali::DaliException e) {
78001       {
78002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78003       };
78004     } catch (...) {
78005       {
78006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78007       };
78008     }
78009   }
78010
78011   jresult = result;
78012   return jresult;
78013 }
78014
78015
78016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
78017   unsigned int jresult ;
78018   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78019   unsigned int result;
78020
78021   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78022   {
78023     try {
78024       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
78025     } catch (std::out_of_range& e) {
78026       {
78027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78028       };
78029     } catch (std::exception& e) {
78030       {
78031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78032       };
78033     } catch (Dali::DaliException e) {
78034       {
78035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78036       };
78037     } catch (...) {
78038       {
78039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78040       };
78041     }
78042   }
78043
78044   jresult = result;
78045   return jresult;
78046 }
78047
78048
78049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78050   int jresult ;
78051   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78052   Dali::Toolkit::Ruler::RulerType result;
78053
78054   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78055   {
78056     try {
78057       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78058     } catch (std::out_of_range& e) {
78059       {
78060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78061       };
78062     } catch (std::exception& e) {
78063       {
78064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78065       };
78066     } catch (Dali::DaliException e) {
78067       {
78068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78069       };
78070     } catch (...) {
78071       {
78072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78073       };
78074     }
78075   }
78076
78077   jresult = (int)result;
78078   return jresult;
78079 }
78080
78081
78082 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78083   unsigned int jresult ;
78084   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78085   bool result;
78086
78087   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78088   {
78089     try {
78090       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78091     } catch (std::out_of_range& e) {
78092       {
78093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78094       };
78095     } catch (std::exception& e) {
78096       {
78097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78098       };
78099     } catch (Dali::DaliException e) {
78100       {
78101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78102       };
78103     } catch (...) {
78104       {
78105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78106       };
78107     }
78108   }
78109
78110   jresult = result;
78111   return jresult;
78112 }
78113
78114
78115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78116   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78117
78118   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78119   {
78120     try {
78121       (arg1)->Enable();
78122     } catch (std::out_of_range& e) {
78123       {
78124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78125       };
78126     } catch (std::exception& e) {
78127       {
78128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78129       };
78130     } catch (Dali::DaliException e) {
78131       {
78132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78133       };
78134     } catch (...) {
78135       {
78136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78137       };
78138     }
78139   }
78140
78141 }
78142
78143
78144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78145   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78146
78147   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78148   {
78149     try {
78150       (arg1)->Disable();
78151     } catch (std::out_of_range& e) {
78152       {
78153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78154       };
78155     } catch (std::exception& e) {
78156       {
78157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78158       };
78159     } catch (Dali::DaliException e) {
78160       {
78161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78162       };
78163     } catch (...) {
78164       {
78165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78166       };
78167     }
78168   }
78169
78170 }
78171
78172
78173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78174   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78175   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78176   Dali::Toolkit::RulerDomain *argp2 ;
78177
78178   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78179   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78180   if (!argp2) {
78181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78182     return ;
78183   }
78184   arg2 = *argp2;
78185   {
78186     try {
78187       (arg1)->SetDomain(arg2);
78188     } catch (std::out_of_range& e) {
78189       {
78190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78191       };
78192     } catch (std::exception& e) {
78193       {
78194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78195       };
78196     } catch (Dali::DaliException e) {
78197       {
78198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78199       };
78200     } catch (...) {
78201       {
78202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78203       };
78204     }
78205   }
78206
78207 }
78208
78209
78210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78211   void * jresult ;
78212   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78213   Dali::Toolkit::RulerDomain *result = 0 ;
78214
78215   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78216   {
78217     try {
78218       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78219     } catch (std::out_of_range& e) {
78220       {
78221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78222       };
78223     } catch (std::exception& e) {
78224       {
78225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78226       };
78227     } catch (Dali::DaliException e) {
78228       {
78229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78230       };
78231     } catch (...) {
78232       {
78233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78234       };
78235     }
78236   }
78237
78238   jresult = (void *)result;
78239   return jresult;
78240 }
78241
78242
78243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78244   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78245
78246   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78247   {
78248     try {
78249       (arg1)->DisableDomain();
78250     } catch (std::out_of_range& e) {
78251       {
78252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78253       };
78254     } catch (std::exception& e) {
78255       {
78256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78257       };
78258     } catch (Dali::DaliException e) {
78259       {
78260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78261       };
78262     } catch (...) {
78263       {
78264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78265       };
78266     }
78267   }
78268
78269 }
78270
78271
78272 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78273   float jresult ;
78274   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78275   float arg2 ;
78276   float arg3 ;
78277   float arg4 ;
78278   float result;
78279
78280   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78281   arg2 = (float)jarg2;
78282   arg3 = (float)jarg3;
78283   arg4 = (float)jarg4;
78284   {
78285     try {
78286       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78287     } catch (std::out_of_range& e) {
78288       {
78289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78290       };
78291     } catch (std::exception& e) {
78292       {
78293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78294       };
78295     } catch (Dali::DaliException e) {
78296       {
78297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78298       };
78299     } catch (...) {
78300       {
78301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78302       };
78303     }
78304   }
78305
78306   jresult = result;
78307   return jresult;
78308 }
78309
78310
78311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78312   float jresult ;
78313   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78314   float arg2 ;
78315   float arg3 ;
78316   float result;
78317
78318   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78319   arg2 = (float)jarg2;
78320   arg3 = (float)jarg3;
78321   {
78322     try {
78323       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78324     } catch (std::out_of_range& e) {
78325       {
78326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78327       };
78328     } catch (std::exception& e) {
78329       {
78330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78331       };
78332     } catch (Dali::DaliException e) {
78333       {
78334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78335       };
78336     } catch (...) {
78337       {
78338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78339       };
78340     }
78341   }
78342
78343   jresult = result;
78344   return jresult;
78345 }
78346
78347
78348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78349   float jresult ;
78350   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78351   float arg2 ;
78352   float result;
78353
78354   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78355   arg2 = (float)jarg2;
78356   {
78357     try {
78358       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78359     } catch (std::out_of_range& e) {
78360       {
78361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78362       };
78363     } catch (std::exception& e) {
78364       {
78365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78366       };
78367     } catch (Dali::DaliException e) {
78368       {
78369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78370       };
78371     } catch (...) {
78372       {
78373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78374       };
78375     }
78376   }
78377
78378   jresult = result;
78379   return jresult;
78380 }
78381
78382
78383 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78384   float jresult ;
78385   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78386   float arg2 ;
78387   float arg3 ;
78388   float arg4 ;
78389   Dali::Toolkit::ClampState *arg5 = 0 ;
78390   float result;
78391
78392   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78393   arg2 = (float)jarg2;
78394   arg3 = (float)jarg3;
78395   arg4 = (float)jarg4;
78396   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78397   if (!arg5) {
78398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78399     return 0;
78400   }
78401   {
78402     try {
78403       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78404     } catch (std::out_of_range& e) {
78405       {
78406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78407       };
78408     } catch (std::exception& e) {
78409       {
78410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78411       };
78412     } catch (Dali::DaliException e) {
78413       {
78414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78415       };
78416     } catch (...) {
78417       {
78418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78419       };
78420     }
78421   }
78422
78423   jresult = result;
78424   return jresult;
78425 }
78426
78427
78428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78429   float jresult ;
78430   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78431   float arg2 ;
78432   float arg3 ;
78433   float arg4 ;
78434   float arg5 ;
78435   float result;
78436
78437   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78438   arg2 = (float)jarg2;
78439   arg3 = (float)jarg3;
78440   arg4 = (float)jarg4;
78441   arg5 = (float)jarg5;
78442   {
78443     try {
78444       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78445     } catch (std::out_of_range& e) {
78446       {
78447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78448       };
78449     } catch (std::exception& e) {
78450       {
78451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78452       };
78453     } catch (Dali::DaliException e) {
78454       {
78455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78456       };
78457     } catch (...) {
78458       {
78459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78460       };
78461     }
78462   }
78463
78464   jresult = result;
78465   return jresult;
78466 }
78467
78468
78469 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78470   float jresult ;
78471   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78472   float arg2 ;
78473   float arg3 ;
78474   float arg4 ;
78475   float result;
78476
78477   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78478   arg2 = (float)jarg2;
78479   arg3 = (float)jarg3;
78480   arg4 = (float)jarg4;
78481   {
78482     try {
78483       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78484     } catch (std::out_of_range& e) {
78485       {
78486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78487       };
78488     } catch (std::exception& e) {
78489       {
78490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78491       };
78492     } catch (Dali::DaliException e) {
78493       {
78494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78495       };
78496     } catch (...) {
78497       {
78498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78499       };
78500     }
78501   }
78502
78503   jresult = result;
78504   return jresult;
78505 }
78506
78507
78508 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78509   float jresult ;
78510   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78511   float arg2 ;
78512   float arg3 ;
78513   float result;
78514
78515   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78516   arg2 = (float)jarg2;
78517   arg3 = (float)jarg3;
78518   {
78519     try {
78520       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78521     } catch (std::out_of_range& e) {
78522       {
78523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78524       };
78525     } catch (std::exception& e) {
78526       {
78527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78528       };
78529     } catch (Dali::DaliException e) {
78530       {
78531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78532       };
78533     } catch (...) {
78534       {
78535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78536       };
78537     }
78538   }
78539
78540   jresult = result;
78541   return jresult;
78542 }
78543
78544
78545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78546   float jresult ;
78547   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78548   float arg2 ;
78549   float result;
78550
78551   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78552   arg2 = (float)jarg2;
78553   {
78554     try {
78555       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78556     } catch (std::out_of_range& e) {
78557       {
78558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78559       };
78560     } catch (std::exception& e) {
78561       {
78562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78563       };
78564     } catch (Dali::DaliException e) {
78565       {
78566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78567       };
78568     } catch (...) {
78569       {
78570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78571       };
78572     }
78573   }
78574
78575   jresult = result;
78576   return jresult;
78577 }
78578
78579
78580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78581   float jresult ;
78582   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78583   float arg2 ;
78584   float arg3 ;
78585   float arg4 ;
78586   float arg5 ;
78587   Dali::Toolkit::ClampState *arg6 = 0 ;
78588   float result;
78589
78590   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78591   arg2 = (float)jarg2;
78592   arg3 = (float)jarg3;
78593   arg4 = (float)jarg4;
78594   arg5 = (float)jarg5;
78595   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78596   if (!arg6) {
78597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78598     return 0;
78599   }
78600   {
78601     try {
78602       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78603     } catch (std::out_of_range& e) {
78604       {
78605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78606       };
78607     } catch (std::exception& e) {
78608       {
78609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78610       };
78611     } catch (Dali::DaliException e) {
78612       {
78613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78614       };
78615     } catch (...) {
78616       {
78617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78618       };
78619     }
78620   }
78621
78622   jresult = result;
78623   return jresult;
78624 }
78625
78626
78627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78628   void * jresult ;
78629   Dali::Toolkit::DefaultRuler *result = 0 ;
78630
78631   {
78632     try {
78633       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78634     } catch (std::out_of_range& e) {
78635       {
78636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78637       };
78638     } catch (std::exception& e) {
78639       {
78640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78641       };
78642     } catch (Dali::DaliException e) {
78643       {
78644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78645       };
78646     } catch (...) {
78647       {
78648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78649       };
78650     }
78651   }
78652
78653   jresult = (void *)result;
78654   return jresult;
78655 }
78656
78657
78658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78659   float jresult ;
78660   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78661   float arg2 ;
78662   float arg3 ;
78663   float result;
78664
78665   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78666   arg2 = (float)jarg2;
78667   arg3 = (float)jarg3;
78668   {
78669     try {
78670       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78671     } catch (std::out_of_range& e) {
78672       {
78673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78674       };
78675     } catch (std::exception& e) {
78676       {
78677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78678       };
78679     } catch (Dali::DaliException e) {
78680       {
78681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78682       };
78683     } catch (...) {
78684       {
78685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78686       };
78687     }
78688   }
78689
78690   jresult = result;
78691   return jresult;
78692 }
78693
78694
78695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78696   float jresult ;
78697   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78698   unsigned int arg2 ;
78699   unsigned int *arg3 = 0 ;
78700   bool arg4 ;
78701   float result;
78702
78703   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78704   arg2 = (unsigned int)jarg2;
78705   arg3 = (unsigned int *)jarg3;
78706   arg4 = jarg4 ? true : false;
78707   {
78708     try {
78709       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78710     } catch (std::out_of_range& e) {
78711       {
78712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78713       };
78714     } catch (std::exception& e) {
78715       {
78716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78717       };
78718     } catch (Dali::DaliException e) {
78719       {
78720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78721       };
78722     } catch (...) {
78723       {
78724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78725       };
78726     }
78727   }
78728
78729   jresult = result;
78730   return jresult;
78731 }
78732
78733
78734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78735   unsigned int jresult ;
78736   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78737   float arg2 ;
78738   bool arg3 ;
78739   unsigned int result;
78740
78741   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78742   arg2 = (float)jarg2;
78743   arg3 = jarg3 ? true : false;
78744   {
78745     try {
78746       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78747     } catch (std::out_of_range& e) {
78748       {
78749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78750       };
78751     } catch (std::exception& e) {
78752       {
78753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78754       };
78755     } catch (Dali::DaliException e) {
78756       {
78757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78758       };
78759     } catch (...) {
78760       {
78761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78762       };
78763     }
78764   }
78765
78766   jresult = result;
78767   return jresult;
78768 }
78769
78770
78771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
78772   unsigned int jresult ;
78773   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78774   unsigned int result;
78775
78776   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78777   {
78778     try {
78779       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
78780     } catch (std::out_of_range& e) {
78781       {
78782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78783       };
78784     } catch (std::exception& e) {
78785       {
78786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78787       };
78788     } catch (Dali::DaliException e) {
78789       {
78790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78791       };
78792     } catch (...) {
78793       {
78794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78795       };
78796     }
78797   }
78798
78799   jresult = result;
78800   return jresult;
78801 }
78802
78803
78804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
78805   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78806
78807   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78808   {
78809     try {
78810       delete arg1;
78811     } catch (std::out_of_range& e) {
78812       {
78813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78814       };
78815     } catch (std::exception& e) {
78816       {
78817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78818       };
78819     } catch (Dali::DaliException e) {
78820       {
78821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78822       };
78823     } catch (...) {
78824       {
78825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78826       };
78827     }
78828   }
78829
78830 }
78831
78832
78833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
78834   void * jresult ;
78835   float arg1 ;
78836   Dali::Toolkit::FixedRuler *result = 0 ;
78837
78838   arg1 = (float)jarg1;
78839   {
78840     try {
78841       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
78842     } catch (std::out_of_range& e) {
78843       {
78844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78845       };
78846     } catch (std::exception& e) {
78847       {
78848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78849       };
78850     } catch (Dali::DaliException e) {
78851       {
78852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78853       };
78854     } catch (...) {
78855       {
78856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78857       };
78858     }
78859   }
78860
78861   jresult = (void *)result;
78862   return jresult;
78863 }
78864
78865
78866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78867   void * jresult ;
78868   Dali::Toolkit::FixedRuler *result = 0 ;
78869
78870   {
78871     try {
78872       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
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 float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78898   float jresult ;
78899   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78900   float arg2 ;
78901   float arg3 ;
78902   float result;
78903
78904   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78905   arg2 = (float)jarg2;
78906   arg3 = (float)jarg3;
78907   {
78908     try {
78909       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78910     } catch (std::out_of_range& e) {
78911       {
78912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78913       };
78914     } catch (std::exception& e) {
78915       {
78916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78917       };
78918     } catch (Dali::DaliException e) {
78919       {
78920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78921       };
78922     } catch (...) {
78923       {
78924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78925       };
78926     }
78927   }
78928
78929   jresult = result;
78930   return jresult;
78931 }
78932
78933
78934 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78935   float jresult ;
78936   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78937   unsigned int arg2 ;
78938   unsigned int *arg3 = 0 ;
78939   bool arg4 ;
78940   float result;
78941
78942   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78943   arg2 = (unsigned int)jarg2;
78944   arg3 = (unsigned int *)jarg3;
78945   arg4 = jarg4 ? true : false;
78946   {
78947     try {
78948       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78949     } catch (std::out_of_range& e) {
78950       {
78951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78952       };
78953     } catch (std::exception& e) {
78954       {
78955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78956       };
78957     } catch (Dali::DaliException e) {
78958       {
78959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78960       };
78961     } catch (...) {
78962       {
78963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78964       };
78965     }
78966   }
78967
78968   jresult = result;
78969   return jresult;
78970 }
78971
78972
78973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78974   unsigned int jresult ;
78975   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78976   float arg2 ;
78977   bool arg3 ;
78978   unsigned int result;
78979
78980   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78981   arg2 = (float)jarg2;
78982   arg3 = jarg3 ? true : false;
78983   {
78984     try {
78985       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78986     } catch (std::out_of_range& e) {
78987       {
78988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78989       };
78990     } catch (std::exception& e) {
78991       {
78992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78993       };
78994     } catch (Dali::DaliException e) {
78995       {
78996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78997       };
78998     } catch (...) {
78999       {
79000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79001       };
79002     }
79003   }
79004
79005   jresult = result;
79006   return jresult;
79007 }
79008
79009
79010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
79011   unsigned int jresult ;
79012   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79013   unsigned int result;
79014
79015   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79016   {
79017     try {
79018       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
79019     } catch (std::out_of_range& e) {
79020       {
79021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79022       };
79023     } catch (std::exception& e) {
79024       {
79025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79026       };
79027     } catch (Dali::DaliException e) {
79028       {
79029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79030       };
79031     } catch (...) {
79032       {
79033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79034       };
79035     }
79036   }
79037
79038   jresult = result;
79039   return jresult;
79040 }
79041
79042
79043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79044   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79045
79046   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79047   {
79048     try {
79049       delete arg1;
79050     } catch (std::out_of_range& e) {
79051       {
79052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79053       };
79054     } catch (std::exception& e) {
79055       {
79056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79057       };
79058     } catch (Dali::DaliException e) {
79059       {
79060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79061       };
79062     } catch (...) {
79063       {
79064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79065       };
79066     }
79067   }
79068
79069 }
79070
79071
79072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79073   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79074   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79075
79076   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79077   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79078   if (arg1) (arg1)->scale = *arg2;
79079 }
79080
79081
79082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79083   void * jresult ;
79084   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79085   Dali::Toolkit::ClampState2D *result = 0 ;
79086
79087   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79088   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79089   jresult = (void *)result;
79090   return jresult;
79091 }
79092
79093
79094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79095   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79096   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79097
79098   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79099   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79100   if (arg1) (arg1)->position = *arg2;
79101 }
79102
79103
79104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79105   void * jresult ;
79106   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79107   Dali::Toolkit::ClampState2D *result = 0 ;
79108
79109   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79110   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79111   jresult = (void *)result;
79112   return jresult;
79113 }
79114
79115
79116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79117   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79118   Dali::Toolkit::ClampState arg2 ;
79119
79120   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79121   arg2 = (Dali::Toolkit::ClampState)jarg2;
79122   if (arg1) (arg1)->rotation = arg2;
79123 }
79124
79125
79126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79127   int jresult ;
79128   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79129   Dali::Toolkit::ClampState result;
79130
79131   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79132   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79133   jresult = (int)result;
79134   return jresult;
79135 }
79136
79137
79138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79139   void * jresult ;
79140   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79141
79142   {
79143     try {
79144       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79145     } catch (std::out_of_range& e) {
79146       {
79147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79148       };
79149     } catch (std::exception& e) {
79150       {
79151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79152       };
79153     } catch (Dali::DaliException e) {
79154       {
79155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79156       };
79157     } catch (...) {
79158       {
79159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79160       };
79161     }
79162   }
79163
79164   jresult = (void *)result;
79165   return jresult;
79166 }
79167
79168
79169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79170   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79171
79172   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79173   {
79174     try {
79175       delete arg1;
79176     } catch (std::out_of_range& e) {
79177       {
79178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79179       };
79180     } catch (std::exception& e) {
79181       {
79182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79183       };
79184     } catch (Dali::DaliException e) {
79185       {
79186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79187       };
79188     } catch (...) {
79189       {
79190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79191       };
79192     }
79193   }
79194
79195 }
79196
79197
79198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79199   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79200   Dali::Toolkit::SnapType arg2 ;
79201
79202   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79203   arg2 = (Dali::Toolkit::SnapType)jarg2;
79204   if (arg1) (arg1)->type = arg2;
79205 }
79206
79207
79208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79209   int jresult ;
79210   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79211   Dali::Toolkit::SnapType result;
79212
79213   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79214   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79215   jresult = (int)result;
79216   return jresult;
79217 }
79218
79219
79220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79221   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79222   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79223
79224   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79225   arg2 = (Dali::Vector2 *)jarg2;
79226   if (arg1) (arg1)->position = *arg2;
79227 }
79228
79229
79230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79231   void * jresult ;
79232   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79233   Dali::Vector2 *result = 0 ;
79234
79235   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79236   result = (Dali::Vector2 *)& ((arg1)->position);
79237   jresult = (void *)result;
79238   return jresult;
79239 }
79240
79241
79242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79243   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79244   float arg2 ;
79245
79246   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79247   arg2 = (float)jarg2;
79248   if (arg1) (arg1)->duration = arg2;
79249 }
79250
79251
79252 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79253   float jresult ;
79254   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79255   float result;
79256
79257   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79258   result = (float) ((arg1)->duration);
79259   jresult = result;
79260   return jresult;
79261 }
79262
79263
79264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79265   void * jresult ;
79266   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79267
79268   {
79269     try {
79270       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79271     } catch (std::out_of_range& e) {
79272       {
79273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79274       };
79275     } catch (std::exception& e) {
79276       {
79277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79278       };
79279     } catch (Dali::DaliException e) {
79280       {
79281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79282       };
79283     } catch (...) {
79284       {
79285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79286       };
79287     }
79288   }
79289
79290   jresult = (void *)result;
79291   return jresult;
79292 }
79293
79294
79295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79296   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79297
79298   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79299   {
79300     try {
79301       delete arg1;
79302     } catch (std::out_of_range& e) {
79303       {
79304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79305       };
79306     } catch (std::exception& e) {
79307       {
79308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79309       };
79310     } catch (Dali::DaliException e) {
79311       {
79312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79313       };
79314     } catch (...) {
79315       {
79316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79317       };
79318     }
79319   }
79320
79321 }
79322
79323
79324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79325   int jresult ;
79326   int result;
79327
79328   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79329   jresult = (int)result;
79330   return jresult;
79331 }
79332
79333
79334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79335   int jresult ;
79336   int result;
79337
79338   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79339   jresult = (int)result;
79340   return jresult;
79341 }
79342
79343
79344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79345   int jresult ;
79346   int result;
79347
79348   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79349   jresult = (int)result;
79350   return jresult;
79351 }
79352
79353
79354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79355   int jresult ;
79356   int result;
79357
79358   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79359   jresult = (int)result;
79360   return jresult;
79361 }
79362
79363
79364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79365   int jresult ;
79366   int result;
79367
79368   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79369   jresult = (int)result;
79370   return jresult;
79371 }
79372
79373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79374   int jresult ;
79375   int result;
79376
79377   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79378   jresult = (int)result;
79379   return jresult;
79380 }
79381
79382
79383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79384   int jresult ;
79385   int result;
79386
79387   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79388   jresult = (int)result;
79389   return jresult;
79390 }
79391
79392
79393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79394   int jresult ;
79395   int result;
79396
79397   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79398   jresult = (int)result;
79399   return jresult;
79400 }
79401
79402
79403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79404   int jresult ;
79405   int result;
79406
79407   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79408   jresult = (int)result;
79409   return jresult;
79410 }
79411
79412
79413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79414   int jresult ;
79415   int result;
79416
79417   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79418   jresult = (int)result;
79419   return jresult;
79420 }
79421
79422
79423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79424   int jresult ;
79425   int result;
79426
79427   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79428   jresult = (int)result;
79429   return jresult;
79430 }
79431
79432
79433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79434   int jresult ;
79435   int result;
79436
79437   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79438   jresult = (int)result;
79439   return jresult;
79440 }
79441
79442
79443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79444   int jresult ;
79445   int result;
79446
79447   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79448   jresult = (int)result;
79449   return jresult;
79450 }
79451
79452
79453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79454   int jresult ;
79455   int result;
79456
79457   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79458   jresult = (int)result;
79459   return jresult;
79460 }
79461
79462
79463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79464   int jresult ;
79465   int result;
79466
79467   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79468   jresult = (int)result;
79469   return jresult;
79470 }
79471
79472
79473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79474   int jresult ;
79475   int result;
79476
79477   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79478   jresult = (int)result;
79479   return jresult;
79480 }
79481
79482
79483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79484   int jresult ;
79485   int result;
79486
79487   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79488   jresult = (int)result;
79489   return jresult;
79490 }
79491
79492
79493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79494   int jresult ;
79495   int result;
79496
79497   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79498   jresult = (int)result;
79499   return jresult;
79500 }
79501
79502
79503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79504   int jresult ;
79505   int result;
79506
79507   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79508   jresult = (int)result;
79509   return jresult;
79510 }
79511
79512
79513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79514   int jresult ;
79515   int result;
79516
79517   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79518   jresult = (int)result;
79519   return jresult;
79520 }
79521
79522
79523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79524   int jresult ;
79525   int result;
79526
79527   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79528   jresult = (int)result;
79529   return jresult;
79530 }
79531
79532
79533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79534   int jresult ;
79535   int result;
79536
79537   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79538   jresult = (int)result;
79539   return jresult;
79540 }
79541
79542
79543 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79544   int jresult ;
79545   int result;
79546
79547   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79548   jresult = (int)result;
79549   return jresult;
79550 }
79551
79552
79553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79554   int jresult ;
79555   int result;
79556
79557   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79558   jresult = (int)result;
79559   return jresult;
79560 }
79561
79562
79563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79564   int jresult ;
79565   int result;
79566
79567   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79568   jresult = (int)result;
79569   return jresult;
79570 }
79571
79572
79573 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79574   int jresult ;
79575   int result;
79576
79577   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79578   jresult = (int)result;
79579   return jresult;
79580 }
79581
79582
79583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79584   void * jresult ;
79585   Dali::Toolkit::ScrollView::Property *result = 0 ;
79586
79587   {
79588     try {
79589       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79590     } catch (std::out_of_range& e) {
79591       {
79592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79593       };
79594     } catch (std::exception& e) {
79595       {
79596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79597       };
79598     } catch (Dali::DaliException e) {
79599       {
79600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79601       };
79602     } catch (...) {
79603       {
79604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79605       };
79606     }
79607   }
79608
79609   jresult = (void *)result;
79610   return jresult;
79611 }
79612
79613
79614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79615   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79616
79617   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79618   {
79619     try {
79620       delete arg1;
79621     } catch (std::out_of_range& e) {
79622       {
79623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79624       };
79625     } catch (std::exception& e) {
79626       {
79627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79628       };
79629     } catch (Dali::DaliException e) {
79630       {
79631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79632       };
79633     } catch (...) {
79634       {
79635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79636       };
79637     }
79638   }
79639
79640 }
79641
79642
79643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79644   void * jresult ;
79645   Dali::Toolkit::ScrollView *result = 0 ;
79646
79647   {
79648     try {
79649       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79650     } catch (std::out_of_range& e) {
79651       {
79652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79653       };
79654     } catch (std::exception& e) {
79655       {
79656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79657       };
79658     } catch (Dali::DaliException e) {
79659       {
79660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79661       };
79662     } catch (...) {
79663       {
79664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79665       };
79666     }
79667   }
79668
79669   jresult = (void *)result;
79670   return jresult;
79671 }
79672
79673
79674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79675   void * jresult ;
79676   Dali::Toolkit::ScrollView *arg1 = 0 ;
79677   Dali::Toolkit::ScrollView *result = 0 ;
79678
79679   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79680   if (!arg1) {
79681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79682     return 0;
79683   }
79684   {
79685     try {
79686       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79687     } catch (std::out_of_range& e) {
79688       {
79689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79690       };
79691     } catch (std::exception& e) {
79692       {
79693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79694       };
79695     } catch (Dali::DaliException e) {
79696       {
79697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79698       };
79699     } catch (...) {
79700       {
79701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79702       };
79703     }
79704   }
79705
79706   jresult = (void *)result;
79707   return jresult;
79708 }
79709
79710
79711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79712   void * jresult ;
79713   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79714   Dali::Toolkit::ScrollView *arg2 = 0 ;
79715   Dali::Toolkit::ScrollView *result = 0 ;
79716
79717   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79718   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79719   if (!arg2) {
79720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79721     return 0;
79722   }
79723   {
79724     try {
79725       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79726     } catch (std::out_of_range& e) {
79727       {
79728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79729       };
79730     } catch (std::exception& e) {
79731       {
79732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79733       };
79734     } catch (Dali::DaliException e) {
79735       {
79736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79737       };
79738     } catch (...) {
79739       {
79740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79741       };
79742     }
79743   }
79744
79745   jresult = (void *)result;
79746   return jresult;
79747 }
79748
79749
79750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79751   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79752
79753   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79754   {
79755     try {
79756       delete arg1;
79757     } catch (std::out_of_range& e) {
79758       {
79759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79760       };
79761     } catch (std::exception& e) {
79762       {
79763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79764       };
79765     } catch (Dali::DaliException e) {
79766       {
79767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79768       };
79769     } catch (...) {
79770       {
79771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79772       };
79773     }
79774   }
79775
79776 }
79777
79778
79779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
79780   void * jresult ;
79781   Dali::Toolkit::ScrollView result;
79782
79783   {
79784     try {
79785       result = Dali::Toolkit::ScrollView::New();
79786     } catch (std::out_of_range& e) {
79787       {
79788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79789       };
79790     } catch (std::exception& e) {
79791       {
79792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79793       };
79794     } catch (Dali::DaliException e) {
79795       {
79796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79797       };
79798     } catch (...) {
79799       {
79800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79801       };
79802     }
79803   }
79804
79805   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79806   return jresult;
79807 }
79808
79809
79810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
79811   void * jresult ;
79812   Dali::BaseHandle arg1 ;
79813   Dali::BaseHandle *argp1 ;
79814   Dali::Toolkit::ScrollView result;
79815
79816   argp1 = (Dali::BaseHandle *)jarg1;
79817   if (!argp1) {
79818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79819     return 0;
79820   }
79821   arg1 = *argp1;
79822   {
79823     try {
79824       result = Dali::Toolkit::ScrollView::DownCast(arg1);
79825     } catch (std::out_of_range& e) {
79826       {
79827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79828       };
79829     } catch (std::exception& e) {
79830       {
79831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79832       };
79833     } catch (Dali::DaliException e) {
79834       {
79835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79836       };
79837     } catch (...) {
79838       {
79839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79840       };
79841     }
79842   }
79843
79844   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79845   return jresult;
79846 }
79847
79848
79849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79850   void * jresult ;
79851   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79852   Dali::AlphaFunction result;
79853
79854   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79855   {
79856     try {
79857       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79858     } catch (std::out_of_range& e) {
79859       {
79860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79861       };
79862     } catch (std::exception& e) {
79863       {
79864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79865       };
79866     } catch (Dali::DaliException e) {
79867       {
79868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79869       };
79870     } catch (...) {
79871       {
79872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79873       };
79874     }
79875   }
79876
79877   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79878   return jresult;
79879 }
79880
79881
79882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79883   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79884   Dali::AlphaFunction arg2 ;
79885   Dali::AlphaFunction *argp2 ;
79886
79887   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79888   argp2 = (Dali::AlphaFunction *)jarg2;
79889   if (!argp2) {
79890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79891     return ;
79892   }
79893   arg2 = *argp2;
79894   {
79895     try {
79896       (arg1)->SetScrollSnapAlphaFunction(arg2);
79897     } catch (std::out_of_range& e) {
79898       {
79899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79900       };
79901     } catch (std::exception& e) {
79902       {
79903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79904       };
79905     } catch (Dali::DaliException e) {
79906       {
79907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79908       };
79909     } catch (...) {
79910       {
79911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79912       };
79913     }
79914   }
79915
79916 }
79917
79918
79919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79920   void * jresult ;
79921   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79922   Dali::AlphaFunction result;
79923
79924   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79925   {
79926     try {
79927       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79928     } catch (std::out_of_range& e) {
79929       {
79930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79931       };
79932     } catch (std::exception& e) {
79933       {
79934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79935       };
79936     } catch (Dali::DaliException e) {
79937       {
79938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79939       };
79940     } catch (...) {
79941       {
79942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79943       };
79944     }
79945   }
79946
79947   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79948   return jresult;
79949 }
79950
79951
79952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79953   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79954   Dali::AlphaFunction arg2 ;
79955   Dali::AlphaFunction *argp2 ;
79956
79957   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79958   argp2 = (Dali::AlphaFunction *)jarg2;
79959   if (!argp2) {
79960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79961     return ;
79962   }
79963   arg2 = *argp2;
79964   {
79965     try {
79966       (arg1)->SetScrollFlickAlphaFunction(arg2);
79967     } catch (std::out_of_range& e) {
79968       {
79969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79970       };
79971     } catch (std::exception& e) {
79972       {
79973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79974       };
79975     } catch (Dali::DaliException e) {
79976       {
79977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79978       };
79979     } catch (...) {
79980       {
79981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79982       };
79983     }
79984   }
79985
79986 }
79987
79988
79989 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79990   float jresult ;
79991   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79992   float result;
79993
79994   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79995   {
79996     try {
79997       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
79998     } catch (std::out_of_range& e) {
79999       {
80000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80001       };
80002     } catch (std::exception& e) {
80003       {
80004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80005       };
80006     } catch (Dali::DaliException e) {
80007       {
80008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80009       };
80010     } catch (...) {
80011       {
80012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80013       };
80014     }
80015   }
80016
80017   jresult = result;
80018   return jresult;
80019 }
80020
80021
80022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
80023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80024   float arg2 ;
80025
80026   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80027   arg2 = (float)jarg2;
80028   {
80029     try {
80030       (arg1)->SetScrollSnapDuration(arg2);
80031     } catch (std::out_of_range& e) {
80032       {
80033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80034       };
80035     } catch (std::exception& e) {
80036       {
80037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80038       };
80039     } catch (Dali::DaliException e) {
80040       {
80041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80042       };
80043     } catch (...) {
80044       {
80045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80046       };
80047     }
80048   }
80049
80050 }
80051
80052
80053 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80054   float jresult ;
80055   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80056   float result;
80057
80058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80059   {
80060     try {
80061       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80062     } catch (std::out_of_range& e) {
80063       {
80064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80065       };
80066     } catch (std::exception& e) {
80067       {
80068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80069       };
80070     } catch (Dali::DaliException e) {
80071       {
80072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80073       };
80074     } catch (...) {
80075       {
80076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80077       };
80078     }
80079   }
80080
80081   jresult = result;
80082   return jresult;
80083 }
80084
80085
80086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80087   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80088   float arg2 ;
80089
80090   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80091   arg2 = (float)jarg2;
80092   {
80093     try {
80094       (arg1)->SetScrollFlickDuration(arg2);
80095     } catch (std::out_of_range& e) {
80096       {
80097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80098       };
80099     } catch (std::exception& e) {
80100       {
80101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80102       };
80103     } catch (Dali::DaliException e) {
80104       {
80105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80106       };
80107     } catch (...) {
80108       {
80109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80110       };
80111     }
80112   }
80113
80114 }
80115
80116
80117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80118   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80119   Dali::Toolkit::RulerPtr arg2 ;
80120   Dali::Toolkit::RulerPtr *argp2 ;
80121
80122   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80123   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80124   if (!argp2) {
80125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80126     return ;
80127   }
80128   arg2 = *argp2;
80129   {
80130     try {
80131       (arg1)->SetRulerX(arg2);
80132     } catch (std::out_of_range& e) {
80133       {
80134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80135       };
80136     } catch (std::exception& e) {
80137       {
80138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80139       };
80140     } catch (Dali::DaliException e) {
80141       {
80142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80143       };
80144     } catch (...) {
80145       {
80146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80147       };
80148     }
80149   }
80150
80151 }
80152
80153
80154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80155   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80156   Dali::Toolkit::RulerPtr arg2 ;
80157   Dali::Toolkit::RulerPtr *argp2 ;
80158
80159   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80160   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80161   if (!argp2) {
80162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80163     return ;
80164   }
80165   arg2 = *argp2;
80166   {
80167     try {
80168       (arg1)->SetRulerY(arg2);
80169     } catch (std::out_of_range& e) {
80170       {
80171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80172       };
80173     } catch (std::exception& e) {
80174       {
80175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80176       };
80177     } catch (Dali::DaliException e) {
80178       {
80179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80180       };
80181     } catch (...) {
80182       {
80183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80184       };
80185     }
80186   }
80187
80188 }
80189
80190
80191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80192   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80193   bool arg2 ;
80194
80195   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80196   arg2 = jarg2 ? true : false;
80197   {
80198     try {
80199       (arg1)->SetScrollSensitive(arg2);
80200     } catch (std::out_of_range& e) {
80201       {
80202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80203       };
80204     } catch (std::exception& e) {
80205       {
80206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80207       };
80208     } catch (Dali::DaliException e) {
80209       {
80210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80211       };
80212     } catch (...) {
80213       {
80214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80215       };
80216     }
80217   }
80218
80219 }
80220
80221
80222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80223   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80224   float arg2 ;
80225   float arg3 ;
80226
80227   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80228   arg2 = (float)jarg2;
80229   arg3 = (float)jarg3;
80230   {
80231     try {
80232       (arg1)->SetMaxOvershoot(arg2,arg3);
80233     } catch (std::out_of_range& e) {
80234       {
80235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80236       };
80237     } catch (std::exception& e) {
80238       {
80239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80240       };
80241     } catch (Dali::DaliException e) {
80242       {
80243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80244       };
80245     } catch (...) {
80246       {
80247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80248       };
80249     }
80250   }
80251
80252 }
80253
80254
80255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80256   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80257   Dali::AlphaFunction arg2 ;
80258   Dali::AlphaFunction *argp2 ;
80259
80260   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80261   argp2 = (Dali::AlphaFunction *)jarg2;
80262   if (!argp2) {
80263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80264     return ;
80265   }
80266   arg2 = *argp2;
80267   {
80268     try {
80269       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80270     } catch (std::out_of_range& e) {
80271       {
80272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80273       };
80274     } catch (std::exception& e) {
80275       {
80276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80277       };
80278     } catch (Dali::DaliException e) {
80279       {
80280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80281       };
80282     } catch (...) {
80283       {
80284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80285       };
80286     }
80287   }
80288
80289 }
80290
80291
80292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80293   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80294   float arg2 ;
80295
80296   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80297   arg2 = (float)jarg2;
80298   {
80299     try {
80300       (arg1)->SetSnapOvershootDuration(arg2);
80301     } catch (std::out_of_range& e) {
80302       {
80303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80304       };
80305     } catch (std::exception& e) {
80306       {
80307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80308       };
80309     } catch (Dali::DaliException e) {
80310       {
80311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80312       };
80313     } catch (...) {
80314       {
80315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80316       };
80317     }
80318   }
80319
80320 }
80321
80322
80323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80324   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80325   bool arg2 ;
80326
80327   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80328   arg2 = jarg2 ? true : false;
80329   {
80330     try {
80331       (arg1)->SetActorAutoSnap(arg2);
80332     } catch (std::out_of_range& e) {
80333       {
80334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80335       };
80336     } catch (std::exception& e) {
80337       {
80338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80339       };
80340     } catch (Dali::DaliException e) {
80341       {
80342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80343       };
80344     } catch (...) {
80345       {
80346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80347       };
80348     }
80349   }
80350
80351 }
80352
80353
80354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80355   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80356   bool arg2 ;
80357
80358   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80359   arg2 = jarg2 ? true : false;
80360   {
80361     try {
80362       (arg1)->SetWrapMode(arg2);
80363     } catch (std::out_of_range& e) {
80364       {
80365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80366       };
80367     } catch (std::exception& e) {
80368       {
80369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80370       };
80371     } catch (Dali::DaliException e) {
80372       {
80373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80374       };
80375     } catch (...) {
80376       {
80377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80378       };
80379     }
80380   }
80381
80382 }
80383
80384
80385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80386   int jresult ;
80387   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80388   int result;
80389
80390   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80391   {
80392     try {
80393       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80394     } catch (std::out_of_range& e) {
80395       {
80396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80397       };
80398     } catch (std::exception& e) {
80399       {
80400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80401       };
80402     } catch (Dali::DaliException e) {
80403       {
80404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80405       };
80406     } catch (...) {
80407       {
80408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80409       };
80410     }
80411   }
80412
80413   jresult = result;
80414   return jresult;
80415 }
80416
80417
80418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80419   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80420   int arg2 ;
80421
80422   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80423   arg2 = (int)jarg2;
80424   {
80425     try {
80426       (arg1)->SetScrollUpdateDistance(arg2);
80427     } catch (std::out_of_range& e) {
80428       {
80429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80430       };
80431     } catch (std::exception& e) {
80432       {
80433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80434       };
80435     } catch (Dali::DaliException e) {
80436       {
80437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80438       };
80439     } catch (...) {
80440       {
80441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80442       };
80443     }
80444   }
80445
80446 }
80447
80448
80449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80450   unsigned int jresult ;
80451   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80452   bool result;
80453
80454   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80455   {
80456     try {
80457       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80458     } catch (std::out_of_range& e) {
80459       {
80460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80461       };
80462     } catch (std::exception& e) {
80463       {
80464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80465       };
80466     } catch (Dali::DaliException e) {
80467       {
80468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80469       };
80470     } catch (...) {
80471       {
80472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80473       };
80474     }
80475   }
80476
80477   jresult = result;
80478   return jresult;
80479 }
80480
80481
80482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80483   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80484   bool arg2 ;
80485
80486   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80487   arg2 = jarg2 ? true : false;
80488   {
80489     try {
80490       (arg1)->SetAxisAutoLock(arg2);
80491     } catch (std::out_of_range& e) {
80492       {
80493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80494       };
80495     } catch (std::exception& e) {
80496       {
80497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80498       };
80499     } catch (Dali::DaliException e) {
80500       {
80501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80502       };
80503     } catch (...) {
80504       {
80505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80506       };
80507     }
80508   }
80509
80510 }
80511
80512
80513 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80514   float jresult ;
80515   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80516   float result;
80517
80518   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80519   {
80520     try {
80521       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80522     } catch (std::out_of_range& e) {
80523       {
80524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80525       };
80526     } catch (std::exception& e) {
80527       {
80528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80529       };
80530     } catch (Dali::DaliException e) {
80531       {
80532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80533       };
80534     } catch (...) {
80535       {
80536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80537       };
80538     }
80539   }
80540
80541   jresult = result;
80542   return jresult;
80543 }
80544
80545
80546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80547   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80548   float arg2 ;
80549
80550   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80551   arg2 = (float)jarg2;
80552   {
80553     try {
80554       (arg1)->SetAxisAutoLockGradient(arg2);
80555     } catch (std::out_of_range& e) {
80556       {
80557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80558       };
80559     } catch (std::exception& e) {
80560       {
80561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80562       };
80563     } catch (Dali::DaliException e) {
80564       {
80565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80566       };
80567     } catch (...) {
80568       {
80569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80570       };
80571     }
80572   }
80573
80574 }
80575
80576
80577 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80578   float jresult ;
80579   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80580   float result;
80581
80582   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80583   {
80584     try {
80585       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80586     } catch (std::out_of_range& e) {
80587       {
80588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80589       };
80590     } catch (std::exception& e) {
80591       {
80592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80593       };
80594     } catch (Dali::DaliException e) {
80595       {
80596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80597       };
80598     } catch (...) {
80599       {
80600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80601       };
80602     }
80603   }
80604
80605   jresult = result;
80606   return jresult;
80607 }
80608
80609
80610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80611   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80612   float arg2 ;
80613
80614   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80615   arg2 = (float)jarg2;
80616   {
80617     try {
80618       (arg1)->SetFrictionCoefficient(arg2);
80619     } catch (std::out_of_range& e) {
80620       {
80621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80622       };
80623     } catch (std::exception& e) {
80624       {
80625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80626       };
80627     } catch (Dali::DaliException e) {
80628       {
80629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80630       };
80631     } catch (...) {
80632       {
80633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80634       };
80635     }
80636   }
80637
80638 }
80639
80640
80641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80642   float jresult ;
80643   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80644   float result;
80645
80646   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80647   {
80648     try {
80649       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80650     } catch (std::out_of_range& e) {
80651       {
80652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80653       };
80654     } catch (std::exception& e) {
80655       {
80656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80657       };
80658     } catch (Dali::DaliException e) {
80659       {
80660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80661       };
80662     } catch (...) {
80663       {
80664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80665       };
80666     }
80667   }
80668
80669   jresult = result;
80670   return jresult;
80671 }
80672
80673
80674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80676   float arg2 ;
80677
80678   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80679   arg2 = (float)jarg2;
80680   {
80681     try {
80682       (arg1)->SetFlickSpeedCoefficient(arg2);
80683     } catch (std::out_of_range& e) {
80684       {
80685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80686       };
80687     } catch (std::exception& e) {
80688       {
80689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80690       };
80691     } catch (Dali::DaliException e) {
80692       {
80693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80694       };
80695     } catch (...) {
80696       {
80697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80698       };
80699     }
80700   }
80701
80702 }
80703
80704
80705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80706   void * jresult ;
80707   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80708   Dali::Vector2 result;
80709
80710   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80711   {
80712     try {
80713       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80714     } catch (std::out_of_range& e) {
80715       {
80716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80717       };
80718     } catch (std::exception& e) {
80719       {
80720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80721       };
80722     } catch (Dali::DaliException e) {
80723       {
80724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80725       };
80726     } catch (...) {
80727       {
80728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80729       };
80730     }
80731   }
80732
80733   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80734   return jresult;
80735 }
80736
80737
80738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80739   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80740   Dali::Vector2 *arg2 = 0 ;
80741
80742   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80743   arg2 = (Dali::Vector2 *)jarg2;
80744   if (!arg2) {
80745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80746     return ;
80747   }
80748   {
80749     try {
80750       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80751     } catch (std::out_of_range& e) {
80752       {
80753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80754       };
80755     } catch (std::exception& e) {
80756       {
80757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80758       };
80759     } catch (Dali::DaliException e) {
80760       {
80761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80762       };
80763     } catch (...) {
80764       {
80765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80766       };
80767     }
80768   }
80769
80770 }
80771
80772
80773 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
80774   float jresult ;
80775   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80776   float result;
80777
80778   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80779   {
80780     try {
80781       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
80782     } catch (std::out_of_range& e) {
80783       {
80784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80785       };
80786     } catch (std::exception& e) {
80787       {
80788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80789       };
80790     } catch (Dali::DaliException e) {
80791       {
80792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80793       };
80794     } catch (...) {
80795       {
80796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80797       };
80798     }
80799   }
80800
80801   jresult = result;
80802   return jresult;
80803 }
80804
80805
80806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
80807   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80808   float arg2 ;
80809
80810   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80811   arg2 = (float)jarg2;
80812   {
80813     try {
80814       (arg1)->SetMinimumSpeedForFlick(arg2);
80815     } catch (std::out_of_range& e) {
80816       {
80817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80818       };
80819     } catch (std::exception& e) {
80820       {
80821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80822       };
80823     } catch (Dali::DaliException e) {
80824       {
80825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80826       };
80827     } catch (...) {
80828       {
80829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80830       };
80831     }
80832   }
80833
80834 }
80835
80836
80837 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
80838   float jresult ;
80839   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80840   float result;
80841
80842   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80843   {
80844     try {
80845       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80846     } catch (std::out_of_range& e) {
80847       {
80848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80849       };
80850     } catch (std::exception& e) {
80851       {
80852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80853       };
80854     } catch (Dali::DaliException e) {
80855       {
80856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80857       };
80858     } catch (...) {
80859       {
80860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80861       };
80862     }
80863   }
80864
80865   jresult = result;
80866   return jresult;
80867 }
80868
80869
80870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80871   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80872   float arg2 ;
80873
80874   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80875   arg2 = (float)jarg2;
80876   {
80877     try {
80878       (arg1)->SetMaxFlickSpeed(arg2);
80879     } catch (std::out_of_range& e) {
80880       {
80881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80882       };
80883     } catch (std::exception& e) {
80884       {
80885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80886       };
80887     } catch (Dali::DaliException e) {
80888       {
80889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80890       };
80891     } catch (...) {
80892       {
80893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80894       };
80895     }
80896   }
80897
80898 }
80899
80900
80901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
80902   void * jresult ;
80903   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80904   Dali::Vector2 result;
80905
80906   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80907   {
80908     try {
80909       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80910     } catch (std::out_of_range& e) {
80911       {
80912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80913       };
80914     } catch (std::exception& e) {
80915       {
80916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80917       };
80918     } catch (Dali::DaliException e) {
80919       {
80920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80921       };
80922     } catch (...) {
80923       {
80924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80925       };
80926     }
80927   }
80928
80929   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80930   return jresult;
80931 }
80932
80933
80934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80935   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80936   Dali::Vector2 arg2 ;
80937   Dali::Vector2 *argp2 ;
80938
80939   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80940   argp2 = (Dali::Vector2 *)jarg2;
80941   if (!argp2) {
80942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80943     return ;
80944   }
80945   arg2 = *argp2;
80946   {
80947     try {
80948       (arg1)->SetWheelScrollDistanceStep(arg2);
80949     } catch (std::out_of_range& e) {
80950       {
80951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80952       };
80953     } catch (std::exception& e) {
80954       {
80955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80956       };
80957     } catch (Dali::DaliException e) {
80958       {
80959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80960       };
80961     } catch (...) {
80962       {
80963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80964       };
80965     }
80966   }
80967
80968 }
80969
80970
80971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80972   void * jresult ;
80973   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80974   Dali::Vector2 result;
80975
80976   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80977   {
80978     try {
80979       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80980     } catch (std::out_of_range& e) {
80981       {
80982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80983       };
80984     } catch (std::exception& e) {
80985       {
80986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80987       };
80988     } catch (Dali::DaliException e) {
80989       {
80990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80991       };
80992     } catch (...) {
80993       {
80994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80995       };
80996     }
80997   }
80998
80999   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
81000   return jresult;
81001 }
81002
81003
81004 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
81005   unsigned int jresult ;
81006   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81007   unsigned int result;
81008
81009   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81010   {
81011     try {
81012       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
81013     } catch (std::out_of_range& e) {
81014       {
81015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81016       };
81017     } catch (std::exception& e) {
81018       {
81019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81020       };
81021     } catch (Dali::DaliException e) {
81022       {
81023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81024       };
81025     } catch (...) {
81026       {
81027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81028       };
81029     }
81030   }
81031
81032   jresult = result;
81033   return jresult;
81034 }
81035
81036
81037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81038   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81039   Dali::Vector2 *arg2 = 0 ;
81040
81041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81042   arg2 = (Dali::Vector2 *)jarg2;
81043   if (!arg2) {
81044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81045     return ;
81046   }
81047   {
81048     try {
81049       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81050     } catch (std::out_of_range& e) {
81051       {
81052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81053       };
81054     } catch (std::exception& e) {
81055       {
81056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81057       };
81058     } catch (Dali::DaliException e) {
81059       {
81060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81061       };
81062     } catch (...) {
81063       {
81064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81065       };
81066     }
81067   }
81068
81069 }
81070
81071
81072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81073   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81074   Dali::Vector2 *arg2 = 0 ;
81075   float arg3 ;
81076
81077   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81078   arg2 = (Dali::Vector2 *)jarg2;
81079   if (!arg2) {
81080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81081     return ;
81082   }
81083   arg3 = (float)jarg3;
81084   {
81085     try {
81086       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81087     } catch (std::out_of_range& e) {
81088       {
81089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81090       };
81091     } catch (std::exception& e) {
81092       {
81093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81094       };
81095     } catch (Dali::DaliException e) {
81096       {
81097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81098       };
81099     } catch (...) {
81100       {
81101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81102       };
81103     }
81104   }
81105
81106 }
81107
81108
81109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81110   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81111   Dali::Vector2 *arg2 = 0 ;
81112   float arg3 ;
81113   Dali::AlphaFunction arg4 ;
81114   Dali::AlphaFunction *argp4 ;
81115
81116   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81117   arg2 = (Dali::Vector2 *)jarg2;
81118   if (!arg2) {
81119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81120     return ;
81121   }
81122   arg3 = (float)jarg3;
81123   argp4 = (Dali::AlphaFunction *)jarg4;
81124   if (!argp4) {
81125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81126     return ;
81127   }
81128   arg4 = *argp4;
81129   {
81130     try {
81131       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81132     } catch (std::out_of_range& e) {
81133       {
81134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81135       };
81136     } catch (std::exception& e) {
81137       {
81138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81139       };
81140     } catch (Dali::DaliException e) {
81141       {
81142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81143       };
81144     } catch (...) {
81145       {
81146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81147       };
81148     }
81149   }
81150
81151 }
81152
81153
81154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81155   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81156   Dali::Vector2 *arg2 = 0 ;
81157   float arg3 ;
81158   Dali::Toolkit::DirectionBias arg4 ;
81159   Dali::Toolkit::DirectionBias arg5 ;
81160
81161   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81162   arg2 = (Dali::Vector2 *)jarg2;
81163   if (!arg2) {
81164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81165     return ;
81166   }
81167   arg3 = (float)jarg3;
81168   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81169   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81170   {
81171     try {
81172       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81173     } catch (std::out_of_range& e) {
81174       {
81175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81176       };
81177     } catch (std::exception& e) {
81178       {
81179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81180       };
81181     } catch (Dali::DaliException e) {
81182       {
81183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81184       };
81185     } catch (...) {
81186       {
81187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81188       };
81189     }
81190   }
81191
81192 }
81193
81194
81195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81196   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81197   Dali::Vector2 *arg2 = 0 ;
81198   float arg3 ;
81199   Dali::AlphaFunction arg4 ;
81200   Dali::Toolkit::DirectionBias arg5 ;
81201   Dali::Toolkit::DirectionBias arg6 ;
81202   Dali::AlphaFunction *argp4 ;
81203
81204   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81205   arg2 = (Dali::Vector2 *)jarg2;
81206   if (!arg2) {
81207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81208     return ;
81209   }
81210   arg3 = (float)jarg3;
81211   argp4 = (Dali::AlphaFunction *)jarg4;
81212   if (!argp4) {
81213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81214     return ;
81215   }
81216   arg4 = *argp4;
81217   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81218   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81219   {
81220     try {
81221       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81222     } catch (std::out_of_range& e) {
81223       {
81224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81225       };
81226     } catch (std::exception& e) {
81227       {
81228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81229       };
81230     } catch (Dali::DaliException e) {
81231       {
81232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81233       };
81234     } catch (...) {
81235       {
81236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81237       };
81238     }
81239   }
81240
81241 }
81242
81243
81244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81245   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81246   unsigned int arg2 ;
81247
81248   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81249   arg2 = (unsigned int)jarg2;
81250   {
81251     try {
81252       (arg1)->ScrollTo(arg2);
81253     } catch (std::out_of_range& e) {
81254       {
81255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81256       };
81257     } catch (std::exception& e) {
81258       {
81259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81260       };
81261     } catch (Dali::DaliException e) {
81262       {
81263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81264       };
81265     } catch (...) {
81266       {
81267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81268       };
81269     }
81270   }
81271
81272 }
81273
81274
81275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81276   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81277   unsigned int arg2 ;
81278   float arg3 ;
81279
81280   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81281   arg2 = (unsigned int)jarg2;
81282   arg3 = (float)jarg3;
81283   {
81284     try {
81285       (arg1)->ScrollTo(arg2,arg3);
81286     } catch (std::out_of_range& e) {
81287       {
81288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81289       };
81290     } catch (std::exception& e) {
81291       {
81292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81293       };
81294     } catch (Dali::DaliException e) {
81295       {
81296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81297       };
81298     } catch (...) {
81299       {
81300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81301       };
81302     }
81303   }
81304
81305 }
81306
81307
81308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81309   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81310   unsigned int arg2 ;
81311   float arg3 ;
81312   Dali::Toolkit::DirectionBias arg4 ;
81313
81314   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81315   arg2 = (unsigned int)jarg2;
81316   arg3 = (float)jarg3;
81317   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81318   {
81319     try {
81320       (arg1)->ScrollTo(arg2,arg3,arg4);
81321     } catch (std::out_of_range& e) {
81322       {
81323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81324       };
81325     } catch (std::exception& e) {
81326       {
81327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81328       };
81329     } catch (Dali::DaliException e) {
81330       {
81331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81332       };
81333     } catch (...) {
81334       {
81335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81336       };
81337     }
81338   }
81339
81340 }
81341
81342
81343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81344   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81345   Dali::Actor *arg2 = 0 ;
81346
81347   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81348   arg2 = (Dali::Actor *)jarg2;
81349   if (!arg2) {
81350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81351     return ;
81352   }
81353   {
81354     try {
81355       (arg1)->ScrollTo(*arg2);
81356     } catch (std::out_of_range& e) {
81357       {
81358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81359       };
81360     } catch (std::exception& e) {
81361       {
81362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81363       };
81364     } catch (Dali::DaliException e) {
81365       {
81366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81367       };
81368     } catch (...) {
81369       {
81370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81371       };
81372     }
81373   }
81374
81375 }
81376
81377
81378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81379   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81380   Dali::Actor *arg2 = 0 ;
81381   float arg3 ;
81382
81383   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81384   arg2 = (Dali::Actor *)jarg2;
81385   if (!arg2) {
81386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81387     return ;
81388   }
81389   arg3 = (float)jarg3;
81390   {
81391     try {
81392       (arg1)->ScrollTo(*arg2,arg3);
81393     } catch (std::out_of_range& e) {
81394       {
81395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81396       };
81397     } catch (std::exception& e) {
81398       {
81399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81400       };
81401     } catch (Dali::DaliException e) {
81402       {
81403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81404       };
81405     } catch (...) {
81406       {
81407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81408       };
81409     }
81410   }
81411
81412 }
81413
81414
81415 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81416   unsigned int jresult ;
81417   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81418   bool result;
81419
81420   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81421   {
81422     try {
81423       result = (bool)(arg1)->ScrollToSnapPoint();
81424     } catch (std::out_of_range& e) {
81425       {
81426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81427       };
81428     } catch (std::exception& e) {
81429       {
81430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81431       };
81432     } catch (Dali::DaliException e) {
81433       {
81434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81435       };
81436     } catch (...) {
81437       {
81438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81439       };
81440     }
81441   }
81442
81443   jresult = result;
81444   return jresult;
81445 }
81446
81447
81448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81449   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81450   Dali::Constraint arg2 ;
81451   Dali::Constraint *argp2 ;
81452
81453   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81454   argp2 = (Dali::Constraint *)jarg2;
81455   if (!argp2) {
81456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81457     return ;
81458   }
81459   arg2 = *argp2;
81460   {
81461     try {
81462       (arg1)->ApplyConstraintToChildren(arg2);
81463     } catch (std::out_of_range& e) {
81464       {
81465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81466       };
81467     } catch (std::exception& e) {
81468       {
81469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81470       };
81471     } catch (Dali::DaliException e) {
81472       {
81473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81474       };
81475     } catch (...) {
81476       {
81477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81478       };
81479     }
81480   }
81481
81482 }
81483
81484
81485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81486   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81487
81488   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81489   {
81490     try {
81491       (arg1)->RemoveConstraintsFromChildren();
81492     } catch (std::out_of_range& e) {
81493       {
81494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81495       };
81496     } catch (std::exception& e) {
81497       {
81498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81499       };
81500     } catch (Dali::DaliException e) {
81501       {
81502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81503       };
81504     } catch (...) {
81505       {
81506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81507       };
81508     }
81509   }
81510
81511 }
81512
81513
81514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81515   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81516   Dali::Toolkit::ScrollViewEffect arg2 ;
81517   Dali::Toolkit::ScrollViewEffect *argp2 ;
81518
81519   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81520   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81521   if (!argp2) {
81522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81523     return ;
81524   }
81525   arg2 = *argp2;
81526   {
81527     try {
81528       (arg1)->ApplyEffect(arg2);
81529     } catch (std::out_of_range& e) {
81530       {
81531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81532       };
81533     } catch (std::exception& e) {
81534       {
81535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81536       };
81537     } catch (Dali::DaliException e) {
81538       {
81539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81540       };
81541     } catch (...) {
81542       {
81543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81544       };
81545     }
81546   }
81547
81548 }
81549
81550
81551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81552   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81553   Dali::Toolkit::ScrollViewEffect arg2 ;
81554   Dali::Toolkit::ScrollViewEffect *argp2 ;
81555
81556   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81557   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81558   if (!argp2) {
81559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81560     return ;
81561   }
81562   arg2 = *argp2;
81563   {
81564     try {
81565       (arg1)->RemoveEffect(arg2);
81566     } catch (std::out_of_range& e) {
81567       {
81568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81569       };
81570     } catch (std::exception& e) {
81571       {
81572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81573       };
81574     } catch (Dali::DaliException e) {
81575       {
81576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81577       };
81578     } catch (...) {
81579       {
81580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81581       };
81582     }
81583   }
81584
81585 }
81586
81587
81588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81589   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81590
81591   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81592   {
81593     try {
81594       (arg1)->RemoveAllEffects();
81595     } catch (std::out_of_range& e) {
81596       {
81597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81598       };
81599     } catch (std::exception& e) {
81600       {
81601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81602       };
81603     } catch (Dali::DaliException e) {
81604       {
81605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81606       };
81607     } catch (...) {
81608       {
81609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81610       };
81611     }
81612   }
81613
81614 }
81615
81616
81617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81618   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81619   Dali::Actor arg2 ;
81620   Dali::Actor *argp2 ;
81621
81622   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81623   argp2 = (Dali::Actor *)jarg2;
81624   if (!argp2) {
81625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81626     return ;
81627   }
81628   arg2 = *argp2;
81629   {
81630     try {
81631       (arg1)->BindActor(arg2);
81632     } catch (std::out_of_range& e) {
81633       {
81634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81635       };
81636     } catch (std::exception& e) {
81637       {
81638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81639       };
81640     } catch (Dali::DaliException e) {
81641       {
81642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81643       };
81644     } catch (...) {
81645       {
81646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81647       };
81648     }
81649   }
81650
81651 }
81652
81653
81654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81655   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81656   Dali::Actor arg2 ;
81657   Dali::Actor *argp2 ;
81658
81659   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81660   argp2 = (Dali::Actor *)jarg2;
81661   if (!argp2) {
81662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81663     return ;
81664   }
81665   arg2 = *argp2;
81666   {
81667     try {
81668       (arg1)->UnbindActor(arg2);
81669     } catch (std::out_of_range& e) {
81670       {
81671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81672       };
81673     } catch (std::exception& e) {
81674       {
81675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81676       };
81677     } catch (Dali::DaliException e) {
81678       {
81679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81680       };
81681     } catch (...) {
81682       {
81683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81684       };
81685     }
81686   }
81687
81688 }
81689
81690
81691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81692   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81693   Dali::Radian arg2 ;
81694   Dali::Radian arg3 ;
81695   Dali::Radian *argp2 ;
81696   Dali::Radian *argp3 ;
81697
81698   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81699   argp2 = (Dali::Radian *)jarg2;
81700   if (!argp2) {
81701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81702     return ;
81703   }
81704   arg2 = *argp2;
81705   argp3 = (Dali::Radian *)jarg3;
81706   if (!argp3) {
81707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81708     return ;
81709   }
81710   arg3 = *argp3;
81711   {
81712     try {
81713       (arg1)->SetScrollingDirection(arg2,arg3);
81714     } catch (std::out_of_range& e) {
81715       {
81716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81717       };
81718     } catch (std::exception& e) {
81719       {
81720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81721       };
81722     } catch (Dali::DaliException e) {
81723       {
81724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81725       };
81726     } catch (...) {
81727       {
81728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81729       };
81730     }
81731   }
81732
81733 }
81734
81735
81736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81737   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81738   Dali::Radian arg2 ;
81739   Dali::Radian *argp2 ;
81740
81741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81742   argp2 = (Dali::Radian *)jarg2;
81743   if (!argp2) {
81744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81745     return ;
81746   }
81747   arg2 = *argp2;
81748   {
81749     try {
81750       (arg1)->SetScrollingDirection(arg2);
81751     } catch (std::out_of_range& e) {
81752       {
81753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81754       };
81755     } catch (std::exception& e) {
81756       {
81757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81758       };
81759     } catch (Dali::DaliException e) {
81760       {
81761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81762       };
81763     } catch (...) {
81764       {
81765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81766       };
81767     }
81768   }
81769
81770 }
81771
81772
81773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
81774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81775   Dali::Radian arg2 ;
81776   Dali::Radian *argp2 ;
81777
81778   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81779   argp2 = (Dali::Radian *)jarg2;
81780   if (!argp2) {
81781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81782     return ;
81783   }
81784   arg2 = *argp2;
81785   {
81786     try {
81787       (arg1)->RemoveScrollingDirection(arg2);
81788     } catch (std::out_of_range& e) {
81789       {
81790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81791       };
81792     } catch (std::exception& e) {
81793       {
81794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81795       };
81796     } catch (Dali::DaliException e) {
81797       {
81798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81799       };
81800     } catch (...) {
81801       {
81802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81803       };
81804     }
81805   }
81806
81807 }
81808
81809
81810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
81811   void * jresult ;
81812   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81813   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
81814
81815   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81816   {
81817     try {
81818       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
81819     } catch (std::out_of_range& e) {
81820       {
81821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81822       };
81823     } catch (std::exception& e) {
81824       {
81825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81826       };
81827     } catch (Dali::DaliException e) {
81828       {
81829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81830       };
81831     } catch (...) {
81832       {
81833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81834       };
81835     }
81836   }
81837
81838   jresult = (void *)result;
81839   return jresult;
81840 }
81841
81842
81843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
81844   int jresult ;
81845   int result;
81846
81847   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81848   jresult = (int)result;
81849   return jresult;
81850 }
81851
81852
81853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81854   int jresult ;
81855   int result;
81856
81857   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81858   jresult = (int)result;
81859   return jresult;
81860 }
81861
81862
81863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81864   int jresult ;
81865   int result;
81866
81867   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81868   jresult = (int)result;
81869   return jresult;
81870 }
81871
81872
81873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81874   int jresult ;
81875   int result;
81876
81877   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81878   jresult = (int)result;
81879   return jresult;
81880 }
81881
81882
81883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81884   int jresult ;
81885   int result;
81886
81887   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81888   jresult = (int)result;
81889   return jresult;
81890 }
81891
81892
81893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81894   void * jresult ;
81895   Dali::Toolkit::TableView::Property *result = 0 ;
81896
81897   {
81898     try {
81899       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81900     } catch (std::out_of_range& e) {
81901       {
81902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81903       };
81904     } catch (std::exception& e) {
81905       {
81906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81907       };
81908     } catch (Dali::DaliException e) {
81909       {
81910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81911       };
81912     } catch (...) {
81913       {
81914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81915       };
81916     }
81917   }
81918
81919   jresult = (void *)result;
81920   return jresult;
81921 }
81922
81923
81924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81925   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81926
81927   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81928   {
81929     try {
81930       delete arg1;
81931     } catch (std::out_of_range& e) {
81932       {
81933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81934       };
81935     } catch (std::exception& e) {
81936       {
81937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81938       };
81939     } catch (Dali::DaliException e) {
81940       {
81941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81942       };
81943     } catch (...) {
81944       {
81945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81946       };
81947     }
81948   }
81949
81950 }
81951
81952
81953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81954   int jresult ;
81955   int result;
81956
81957   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81958   jresult = (int)result;
81959   return jresult;
81960 }
81961
81962
81963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81964   int jresult ;
81965   int result;
81966
81967   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81968   jresult = (int)result;
81969   return jresult;
81970 }
81971
81972
81973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81974   int jresult ;
81975   int result;
81976
81977   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81978   jresult = (int)result;
81979   return jresult;
81980 }
81981
81982
81983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81984   int jresult ;
81985   int result;
81986
81987   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81988   jresult = (int)result;
81989   return jresult;
81990 }
81991
81992
81993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81994   int jresult ;
81995   int result;
81996
81997   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81998   jresult = (int)result;
81999   return jresult;
82000 }
82001
82002
82003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
82004   void * jresult ;
82005   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
82006
82007   {
82008     try {
82009       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
82010     } catch (std::out_of_range& e) {
82011       {
82012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82013       };
82014     } catch (std::exception& e) {
82015       {
82016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82017       };
82018     } catch (Dali::DaliException e) {
82019       {
82020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82021       };
82022     } catch (...) {
82023       {
82024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82025       };
82026     }
82027   }
82028
82029   jresult = (void *)result;
82030   return jresult;
82031 }
82032
82033
82034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
82035   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
82036
82037   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82038   {
82039     try {
82040       delete arg1;
82041     } catch (std::out_of_range& e) {
82042       {
82043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82044       };
82045     } catch (std::exception& e) {
82046       {
82047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82048       };
82049     } catch (Dali::DaliException e) {
82050       {
82051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82052       };
82053     } catch (...) {
82054       {
82055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82056       };
82057     }
82058   }
82059
82060 }
82061
82062
82063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82064   void * jresult ;
82065   unsigned int arg1 ;
82066   unsigned int arg2 ;
82067   unsigned int arg3 ;
82068   unsigned int arg4 ;
82069   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82070
82071   arg1 = (unsigned int)jarg1;
82072   arg2 = (unsigned int)jarg2;
82073   arg3 = (unsigned int)jarg3;
82074   arg4 = (unsigned int)jarg4;
82075   {
82076     try {
82077       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
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 = (void *)result;
82098   return jresult;
82099 }
82100
82101
82102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82103   void * jresult ;
82104   unsigned int arg1 ;
82105   unsigned int arg2 ;
82106   unsigned int arg3 ;
82107   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82108
82109   arg1 = (unsigned int)jarg1;
82110   arg2 = (unsigned int)jarg2;
82111   arg3 = (unsigned int)jarg3;
82112   {
82113     try {
82114       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82115     } catch (std::out_of_range& e) {
82116       {
82117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82118       };
82119     } catch (std::exception& e) {
82120       {
82121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82122       };
82123     } catch (Dali::DaliException e) {
82124       {
82125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82126       };
82127     } catch (...) {
82128       {
82129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82130       };
82131     }
82132   }
82133
82134   jresult = (void *)result;
82135   return jresult;
82136 }
82137
82138
82139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82140   void * jresult ;
82141   unsigned int arg1 ;
82142   unsigned int arg2 ;
82143   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82144
82145   arg1 = (unsigned int)jarg1;
82146   arg2 = (unsigned int)jarg2;
82147   {
82148     try {
82149       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82150     } catch (std::out_of_range& e) {
82151       {
82152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82153       };
82154     } catch (std::exception& e) {
82155       {
82156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82157       };
82158     } catch (Dali::DaliException e) {
82159       {
82160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82161       };
82162     } catch (...) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82165       };
82166     }
82167   }
82168
82169   jresult = (void *)result;
82170   return jresult;
82171 }
82172
82173
82174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82175   void * jresult ;
82176   unsigned int arg1 ;
82177   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82178
82179   arg1 = (unsigned int)jarg1;
82180   {
82181     try {
82182       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82183     } catch (std::out_of_range& e) {
82184       {
82185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82186       };
82187     } catch (std::exception& e) {
82188       {
82189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82190       };
82191     } catch (Dali::DaliException e) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82194       };
82195     } catch (...) {
82196       {
82197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82198       };
82199     }
82200   }
82201
82202   jresult = (void *)result;
82203   return jresult;
82204 }
82205
82206
82207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82208   void * jresult ;
82209   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82210
82211   {
82212     try {
82213       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82214     } catch (std::out_of_range& e) {
82215       {
82216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82217       };
82218     } catch (std::exception& e) {
82219       {
82220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82221       };
82222     } catch (Dali::DaliException e) {
82223       {
82224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82225       };
82226     } catch (...) {
82227       {
82228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82229       };
82230     }
82231   }
82232
82233   jresult = (void *)result;
82234   return jresult;
82235 }
82236
82237
82238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82239   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82240   unsigned int arg2 ;
82241
82242   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82243   arg2 = (unsigned int)jarg2;
82244   if (arg1) (arg1)->rowIndex = arg2;
82245 }
82246
82247
82248 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82249   unsigned int jresult ;
82250   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82251   unsigned int result;
82252
82253   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82254   result = (unsigned int) ((arg1)->rowIndex);
82255   jresult = result;
82256   return jresult;
82257 }
82258
82259
82260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82261   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82262   unsigned int arg2 ;
82263
82264   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82265   arg2 = (unsigned int)jarg2;
82266   if (arg1) (arg1)->columnIndex = arg2;
82267 }
82268
82269
82270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82271   unsigned int jresult ;
82272   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82273   unsigned int result;
82274
82275   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82276   result = (unsigned int) ((arg1)->columnIndex);
82277   jresult = result;
82278   return jresult;
82279 }
82280
82281
82282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82283   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82284   unsigned int arg2 ;
82285
82286   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82287   arg2 = (unsigned int)jarg2;
82288   if (arg1) (arg1)->rowSpan = arg2;
82289 }
82290
82291
82292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82293   unsigned int jresult ;
82294   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82295   unsigned int result;
82296
82297   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82298   result = (unsigned int) ((arg1)->rowSpan);
82299   jresult = result;
82300   return jresult;
82301 }
82302
82303
82304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82305   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82306   unsigned int arg2 ;
82307
82308   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82309   arg2 = (unsigned int)jarg2;
82310   if (arg1) (arg1)->columnSpan = arg2;
82311 }
82312
82313
82314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82315   unsigned int jresult ;
82316   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82317   unsigned int result;
82318
82319   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82320   result = (unsigned int) ((arg1)->columnSpan);
82321   jresult = result;
82322   return jresult;
82323 }
82324
82325
82326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82327   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82328
82329   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82330   {
82331     try {
82332       delete arg1;
82333     } catch (std::out_of_range& e) {
82334       {
82335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82336       };
82337     } catch (std::exception& e) {
82338       {
82339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82340       };
82341     } catch (Dali::DaliException e) {
82342       {
82343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82344       };
82345     } catch (...) {
82346       {
82347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82348       };
82349     }
82350   }
82351
82352 }
82353
82354
82355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82356   void * jresult ;
82357   Dali::Toolkit::TableView *result = 0 ;
82358
82359   {
82360     try {
82361       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82362     } catch (std::out_of_range& e) {
82363       {
82364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82365       };
82366     } catch (std::exception& e) {
82367       {
82368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82369       };
82370     } catch (Dali::DaliException e) {
82371       {
82372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82373       };
82374     } catch (...) {
82375       {
82376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82377       };
82378     }
82379   }
82380
82381   jresult = (void *)result;
82382   return jresult;
82383 }
82384
82385
82386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82387   void * jresult ;
82388   Dali::Toolkit::TableView *arg1 = 0 ;
82389   Dali::Toolkit::TableView *result = 0 ;
82390
82391   arg1 = (Dali::Toolkit::TableView *)jarg1;
82392   if (!arg1) {
82393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82394     return 0;
82395   }
82396   {
82397     try {
82398       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82399     } catch (std::out_of_range& e) {
82400       {
82401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82402       };
82403     } catch (std::exception& e) {
82404       {
82405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82406       };
82407     } catch (Dali::DaliException e) {
82408       {
82409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82410       };
82411     } catch (...) {
82412       {
82413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82414       };
82415     }
82416   }
82417
82418   jresult = (void *)result;
82419   return jresult;
82420 }
82421
82422
82423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82424   void * jresult ;
82425   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82426   Dali::Toolkit::TableView *arg2 = 0 ;
82427   Dali::Toolkit::TableView *result = 0 ;
82428
82429   arg1 = (Dali::Toolkit::TableView *)jarg1;
82430   arg2 = (Dali::Toolkit::TableView *)jarg2;
82431   if (!arg2) {
82432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82433     return 0;
82434   }
82435   {
82436     try {
82437       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82438     } catch (std::out_of_range& e) {
82439       {
82440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82441       };
82442     } catch (std::exception& e) {
82443       {
82444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82445       };
82446     } catch (Dali::DaliException e) {
82447       {
82448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82449       };
82450     } catch (...) {
82451       {
82452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82453       };
82454     }
82455   }
82456
82457   jresult = (void *)result;
82458   return jresult;
82459 }
82460
82461
82462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82463   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82464
82465   arg1 = (Dali::Toolkit::TableView *)jarg1;
82466   {
82467     try {
82468       delete arg1;
82469     } catch (std::out_of_range& e) {
82470       {
82471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82472       };
82473     } catch (std::exception& e) {
82474       {
82475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82476       };
82477     } catch (Dali::DaliException e) {
82478       {
82479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82480       };
82481     } catch (...) {
82482       {
82483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82484       };
82485     }
82486   }
82487
82488 }
82489
82490
82491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82492   void * jresult ;
82493   unsigned int arg1 ;
82494   unsigned int arg2 ;
82495   Dali::Toolkit::TableView result;
82496
82497   arg1 = (unsigned int)jarg1;
82498   arg2 = (unsigned int)jarg2;
82499   {
82500     try {
82501       result = Dali::Toolkit::TableView::New(arg1,arg2);
82502     } catch (std::out_of_range& e) {
82503       {
82504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82505       };
82506     } catch (std::exception& e) {
82507       {
82508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82509       };
82510     } catch (Dali::DaliException e) {
82511       {
82512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82513       };
82514     } catch (...) {
82515       {
82516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82517       };
82518     }
82519   }
82520
82521   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82522   return jresult;
82523 }
82524
82525
82526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82527   void * jresult ;
82528   Dali::BaseHandle arg1 ;
82529   Dali::BaseHandle *argp1 ;
82530   Dali::Toolkit::TableView result;
82531
82532   argp1 = (Dali::BaseHandle *)jarg1;
82533   if (!argp1) {
82534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82535     return 0;
82536   }
82537   arg1 = *argp1;
82538   {
82539     try {
82540       result = Dali::Toolkit::TableView::DownCast(arg1);
82541     } catch (std::out_of_range& e) {
82542       {
82543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82544       };
82545     } catch (std::exception& e) {
82546       {
82547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82548       };
82549     } catch (Dali::DaliException e) {
82550       {
82551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82552       };
82553     } catch (...) {
82554       {
82555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82556       };
82557     }
82558   }
82559
82560   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82561   return jresult;
82562 }
82563
82564
82565 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82566   unsigned int jresult ;
82567   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82568   Dali::Actor arg2 ;
82569   Dali::Toolkit::TableView::CellPosition arg3 ;
82570   Dali::Actor *argp2 ;
82571   Dali::Toolkit::TableView::CellPosition *argp3 ;
82572   bool result;
82573
82574   arg1 = (Dali::Toolkit::TableView *)jarg1;
82575   argp2 = (Dali::Actor *)jarg2;
82576   if (!argp2) {
82577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82578     return 0;
82579   }
82580   arg2 = *argp2;
82581   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82582   if (!argp3) {
82583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82584     return 0;
82585   }
82586   arg3 = *argp3;
82587   {
82588     try {
82589       result = (bool)(arg1)->AddChild(arg2,arg3);
82590     } catch (std::out_of_range& e) {
82591       {
82592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82593       };
82594     } catch (std::exception& e) {
82595       {
82596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82597       };
82598     } catch (Dali::DaliException e) {
82599       {
82600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82601       };
82602     } catch (...) {
82603       {
82604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82605       };
82606     }
82607   }
82608
82609   jresult = result;
82610   return jresult;
82611 }
82612
82613
82614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82615   void * jresult ;
82616   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82617   Dali::Toolkit::TableView::CellPosition arg2 ;
82618   Dali::Toolkit::TableView::CellPosition *argp2 ;
82619   Dali::Actor result;
82620
82621   arg1 = (Dali::Toolkit::TableView *)jarg1;
82622   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82623   if (!argp2) {
82624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82625     return 0;
82626   }
82627   arg2 = *argp2;
82628   {
82629     try {
82630       result = (arg1)->GetChildAt(arg2);
82631     } catch (std::out_of_range& e) {
82632       {
82633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82634       };
82635     } catch (std::exception& e) {
82636       {
82637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82638       };
82639     } catch (Dali::DaliException e) {
82640       {
82641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82642       };
82643     } catch (...) {
82644       {
82645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82646       };
82647     }
82648   }
82649
82650   jresult = new Dali::Actor((const Dali::Actor &)result);
82651   return jresult;
82652 }
82653
82654
82655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82656   void * jresult ;
82657   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82658   Dali::Toolkit::TableView::CellPosition arg2 ;
82659   Dali::Toolkit::TableView::CellPosition *argp2 ;
82660   Dali::Actor result;
82661
82662   arg1 = (Dali::Toolkit::TableView *)jarg1;
82663   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82664   if (!argp2) {
82665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82666     return 0;
82667   }
82668   arg2 = *argp2;
82669   {
82670     try {
82671       result = (arg1)->RemoveChildAt(arg2);
82672     } catch (std::out_of_range& e) {
82673       {
82674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82675       };
82676     } catch (std::exception& e) {
82677       {
82678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82679       };
82680     } catch (Dali::DaliException e) {
82681       {
82682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82683       };
82684     } catch (...) {
82685       {
82686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82687       };
82688     }
82689   }
82690
82691   jresult = new Dali::Actor((const Dali::Actor &)result);
82692   return jresult;
82693 }
82694
82695
82696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82697   unsigned int jresult ;
82698   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82699   Dali::Actor arg2 ;
82700   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82701   Dali::Actor *argp2 ;
82702   bool result;
82703
82704   arg1 = (Dali::Toolkit::TableView *)jarg1;
82705   argp2 = (Dali::Actor *)jarg2;
82706   if (!argp2) {
82707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82708     return 0;
82709   }
82710   arg2 = *argp2;
82711   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82712   if (!arg3) {
82713     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82714     return 0;
82715   }
82716   {
82717     try {
82718       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82719     } catch (std::out_of_range& e) {
82720       {
82721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82722       };
82723     } catch (std::exception& e) {
82724       {
82725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82726       };
82727     } catch (Dali::DaliException e) {
82728       {
82729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82730       };
82731     } catch (...) {
82732       {
82733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82734       };
82735     }
82736   }
82737
82738   jresult = result;
82739   return jresult;
82740 }
82741
82742
82743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82744   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82745   unsigned int arg2 ;
82746
82747   arg1 = (Dali::Toolkit::TableView *)jarg1;
82748   arg2 = (unsigned int)jarg2;
82749   {
82750     try {
82751       (arg1)->InsertRow(arg2);
82752     } catch (std::out_of_range& e) {
82753       {
82754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82755       };
82756     } catch (std::exception& e) {
82757       {
82758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82759       };
82760     } catch (Dali::DaliException e) {
82761       {
82762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82763       };
82764     } catch (...) {
82765       {
82766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82767       };
82768     }
82769   }
82770
82771 }
82772
82773
82774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
82775   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82776   unsigned int arg2 ;
82777
82778   arg1 = (Dali::Toolkit::TableView *)jarg1;
82779   arg2 = (unsigned int)jarg2;
82780   {
82781     try {
82782       (arg1)->DeleteRow(arg2);
82783     } catch (std::out_of_range& e) {
82784       {
82785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82786       };
82787     } catch (std::exception& e) {
82788       {
82789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82790       };
82791     } catch (Dali::DaliException e) {
82792       {
82793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82794       };
82795     } catch (...) {
82796       {
82797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82798       };
82799     }
82800   }
82801
82802 }
82803
82804
82805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82806   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82807   unsigned int arg2 ;
82808   std::vector< Dali::Actor > *arg3 = 0 ;
82809
82810   arg1 = (Dali::Toolkit::TableView *)jarg1;
82811   arg2 = (unsigned int)jarg2;
82812   arg3 = (std::vector< Dali::Actor > *)jarg3;
82813   if (!arg3) {
82814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82815     return ;
82816   }
82817   {
82818     try {
82819       (arg1)->DeleteRow(arg2,*arg3);
82820     } catch (std::out_of_range& e) {
82821       {
82822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82823       };
82824     } catch (std::exception& e) {
82825       {
82826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82827       };
82828     } catch (Dali::DaliException e) {
82829       {
82830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82831       };
82832     } catch (...) {
82833       {
82834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82835       };
82836     }
82837   }
82838
82839 }
82840
82841
82842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
82843   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82844   unsigned int arg2 ;
82845
82846   arg1 = (Dali::Toolkit::TableView *)jarg1;
82847   arg2 = (unsigned int)jarg2;
82848   {
82849     try {
82850       (arg1)->InsertColumn(arg2);
82851     } catch (std::out_of_range& e) {
82852       {
82853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82854       };
82855     } catch (std::exception& e) {
82856       {
82857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82858       };
82859     } catch (Dali::DaliException e) {
82860       {
82861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82862       };
82863     } catch (...) {
82864       {
82865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82866       };
82867     }
82868   }
82869
82870 }
82871
82872
82873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82874   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82875   unsigned int arg2 ;
82876
82877   arg1 = (Dali::Toolkit::TableView *)jarg1;
82878   arg2 = (unsigned int)jarg2;
82879   {
82880     try {
82881       (arg1)->DeleteColumn(arg2);
82882     } catch (std::out_of_range& e) {
82883       {
82884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82885       };
82886     } catch (std::exception& e) {
82887       {
82888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82889       };
82890     } catch (Dali::DaliException e) {
82891       {
82892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82893       };
82894     } catch (...) {
82895       {
82896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82897       };
82898     }
82899   }
82900
82901 }
82902
82903
82904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82905   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82906   unsigned int arg2 ;
82907   std::vector< Dali::Actor > *arg3 = 0 ;
82908
82909   arg1 = (Dali::Toolkit::TableView *)jarg1;
82910   arg2 = (unsigned int)jarg2;
82911   arg3 = (std::vector< Dali::Actor > *)jarg3;
82912   if (!arg3) {
82913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82914     return ;
82915   }
82916   {
82917     try {
82918       (arg1)->DeleteColumn(arg2,*arg3);
82919     } catch (std::out_of_range& e) {
82920       {
82921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82922       };
82923     } catch (std::exception& e) {
82924       {
82925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82926       };
82927     } catch (Dali::DaliException e) {
82928       {
82929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82930       };
82931     } catch (...) {
82932       {
82933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82934       };
82935     }
82936   }
82937
82938 }
82939
82940
82941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82942   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82943   unsigned int arg2 ;
82944   unsigned int arg3 ;
82945
82946   arg1 = (Dali::Toolkit::TableView *)jarg1;
82947   arg2 = (unsigned int)jarg2;
82948   arg3 = (unsigned int)jarg3;
82949   {
82950     try {
82951       (arg1)->Resize(arg2,arg3);
82952     } catch (std::out_of_range& e) {
82953       {
82954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82955       };
82956     } catch (std::exception& e) {
82957       {
82958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82959       };
82960     } catch (Dali::DaliException e) {
82961       {
82962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82963       };
82964     } catch (...) {
82965       {
82966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82967       };
82968     }
82969   }
82970
82971 }
82972
82973
82974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82975   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82976   unsigned int arg2 ;
82977   unsigned int arg3 ;
82978   std::vector< Dali::Actor > *arg4 = 0 ;
82979
82980   arg1 = (Dali::Toolkit::TableView *)jarg1;
82981   arg2 = (unsigned int)jarg2;
82982   arg3 = (unsigned int)jarg3;
82983   arg4 = (std::vector< Dali::Actor > *)jarg4;
82984   if (!arg4) {
82985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82986     return ;
82987   }
82988   {
82989     try {
82990       (arg1)->Resize(arg2,arg3,*arg4);
82991     } catch (std::out_of_range& e) {
82992       {
82993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82994       };
82995     } catch (std::exception& e) {
82996       {
82997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82998       };
82999     } catch (Dali::DaliException e) {
83000       {
83001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83002       };
83003     } catch (...) {
83004       {
83005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83006       };
83007     }
83008   }
83009
83010 }
83011
83012
83013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
83014   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83015   Dali::Size arg2 ;
83016   Dali::Size *argp2 ;
83017
83018   arg1 = (Dali::Toolkit::TableView *)jarg1;
83019   argp2 = (Dali::Size *)jarg2;
83020   if (!argp2) {
83021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
83022     return ;
83023   }
83024   arg2 = *argp2;
83025   {
83026     try {
83027       (arg1)->SetCellPadding(arg2);
83028     } catch (std::out_of_range& e) {
83029       {
83030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83031       };
83032     } catch (std::exception& e) {
83033       {
83034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83035       };
83036     } catch (Dali::DaliException e) {
83037       {
83038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83039       };
83040     } catch (...) {
83041       {
83042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83043       };
83044     }
83045   }
83046
83047 }
83048
83049
83050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83051   void * jresult ;
83052   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83053   Dali::Size result;
83054
83055   arg1 = (Dali::Toolkit::TableView *)jarg1;
83056   {
83057     try {
83058       result = (arg1)->GetCellPadding();
83059     } catch (std::out_of_range& e) {
83060       {
83061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83062       };
83063     } catch (std::exception& e) {
83064       {
83065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83066       };
83067     } catch (Dali::DaliException e) {
83068       {
83069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83070       };
83071     } catch (...) {
83072       {
83073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83074       };
83075     }
83076   }
83077
83078   jresult = new Dali::Size((const Dali::Size &)result);
83079   return jresult;
83080 }
83081
83082
83083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83084   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83085   unsigned int arg2 ;
83086
83087   arg1 = (Dali::Toolkit::TableView *)jarg1;
83088   arg2 = (unsigned int)jarg2;
83089   {
83090     try {
83091       (arg1)->SetFitHeight(arg2);
83092     } catch (std::out_of_range& e) {
83093       {
83094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83095       };
83096     } catch (std::exception& e) {
83097       {
83098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83099       };
83100     } catch (Dali::DaliException e) {
83101       {
83102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83103       };
83104     } catch (...) {
83105       {
83106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83107       };
83108     }
83109   }
83110
83111 }
83112
83113
83114 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83115   unsigned int jresult ;
83116   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83117   unsigned int arg2 ;
83118   bool result;
83119
83120   arg1 = (Dali::Toolkit::TableView *)jarg1;
83121   arg2 = (unsigned int)jarg2;
83122   {
83123     try {
83124       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83125     } catch (std::out_of_range& e) {
83126       {
83127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83128       };
83129     } catch (std::exception& e) {
83130       {
83131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83132       };
83133     } catch (Dali::DaliException e) {
83134       {
83135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83136       };
83137     } catch (...) {
83138       {
83139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83140       };
83141     }
83142   }
83143
83144   jresult = result;
83145   return jresult;
83146 }
83147
83148
83149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83150   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83151   unsigned int arg2 ;
83152
83153   arg1 = (Dali::Toolkit::TableView *)jarg1;
83154   arg2 = (unsigned int)jarg2;
83155   {
83156     try {
83157       (arg1)->SetFitWidth(arg2);
83158     } catch (std::out_of_range& e) {
83159       {
83160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83161       };
83162     } catch (std::exception& e) {
83163       {
83164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83165       };
83166     } catch (Dali::DaliException e) {
83167       {
83168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83169       };
83170     } catch (...) {
83171       {
83172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83173       };
83174     }
83175   }
83176
83177 }
83178
83179
83180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83181   unsigned int jresult ;
83182   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83183   unsigned int arg2 ;
83184   bool result;
83185
83186   arg1 = (Dali::Toolkit::TableView *)jarg1;
83187   arg2 = (unsigned int)jarg2;
83188   {
83189     try {
83190       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83191     } catch (std::out_of_range& e) {
83192       {
83193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83194       };
83195     } catch (std::exception& e) {
83196       {
83197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83198       };
83199     } catch (Dali::DaliException e) {
83200       {
83201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83202       };
83203     } catch (...) {
83204       {
83205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83206       };
83207     }
83208   }
83209
83210   jresult = result;
83211   return jresult;
83212 }
83213
83214
83215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83216   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83217   unsigned int arg2 ;
83218   float arg3 ;
83219
83220   arg1 = (Dali::Toolkit::TableView *)jarg1;
83221   arg2 = (unsigned int)jarg2;
83222   arg3 = (float)jarg3;
83223   {
83224     try {
83225       (arg1)->SetFixedHeight(arg2,arg3);
83226     } catch (std::out_of_range& e) {
83227       {
83228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83229       };
83230     } catch (std::exception& e) {
83231       {
83232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83233       };
83234     } catch (Dali::DaliException e) {
83235       {
83236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83237       };
83238     } catch (...) {
83239       {
83240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83241       };
83242     }
83243   }
83244
83245 }
83246
83247
83248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83249   float jresult ;
83250   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83251   unsigned int arg2 ;
83252   float result;
83253
83254   arg1 = (Dali::Toolkit::TableView *)jarg1;
83255   arg2 = (unsigned int)jarg2;
83256   {
83257     try {
83258       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83259     } catch (std::out_of_range& e) {
83260       {
83261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83262       };
83263     } catch (std::exception& e) {
83264       {
83265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83266       };
83267     } catch (Dali::DaliException e) {
83268       {
83269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83270       };
83271     } catch (...) {
83272       {
83273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83274       };
83275     }
83276   }
83277
83278   jresult = result;
83279   return jresult;
83280 }
83281
83282
83283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83284   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83285   unsigned int arg2 ;
83286   float arg3 ;
83287
83288   arg1 = (Dali::Toolkit::TableView *)jarg1;
83289   arg2 = (unsigned int)jarg2;
83290   arg3 = (float)jarg3;
83291   {
83292     try {
83293       (arg1)->SetRelativeHeight(arg2,arg3);
83294     } catch (std::out_of_range& e) {
83295       {
83296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83297       };
83298     } catch (std::exception& e) {
83299       {
83300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83301       };
83302     } catch (Dali::DaliException e) {
83303       {
83304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83305       };
83306     } catch (...) {
83307       {
83308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83309       };
83310     }
83311   }
83312
83313 }
83314
83315
83316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83317   float jresult ;
83318   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83319   unsigned int arg2 ;
83320   float result;
83321
83322   arg1 = (Dali::Toolkit::TableView *)jarg1;
83323   arg2 = (unsigned int)jarg2;
83324   {
83325     try {
83326       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83327     } catch (std::out_of_range& e) {
83328       {
83329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83330       };
83331     } catch (std::exception& e) {
83332       {
83333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83334       };
83335     } catch (Dali::DaliException e) {
83336       {
83337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83338       };
83339     } catch (...) {
83340       {
83341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83342       };
83343     }
83344   }
83345
83346   jresult = result;
83347   return jresult;
83348 }
83349
83350
83351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83352   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83353   unsigned int arg2 ;
83354   float arg3 ;
83355
83356   arg1 = (Dali::Toolkit::TableView *)jarg1;
83357   arg2 = (unsigned int)jarg2;
83358   arg3 = (float)jarg3;
83359   {
83360     try {
83361       (arg1)->SetFixedWidth(arg2,arg3);
83362     } catch (std::out_of_range& e) {
83363       {
83364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83365       };
83366     } catch (std::exception& e) {
83367       {
83368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83369       };
83370     } catch (Dali::DaliException e) {
83371       {
83372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83373       };
83374     } catch (...) {
83375       {
83376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83377       };
83378     }
83379   }
83380
83381 }
83382
83383
83384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83385   float jresult ;
83386   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83387   unsigned int arg2 ;
83388   float result;
83389
83390   arg1 = (Dali::Toolkit::TableView *)jarg1;
83391   arg2 = (unsigned int)jarg2;
83392   {
83393     try {
83394       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83395     } catch (std::out_of_range& e) {
83396       {
83397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83398       };
83399     } catch (std::exception& e) {
83400       {
83401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83402       };
83403     } catch (Dali::DaliException e) {
83404       {
83405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83406       };
83407     } catch (...) {
83408       {
83409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83410       };
83411     }
83412   }
83413
83414   jresult = result;
83415   return jresult;
83416 }
83417
83418
83419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83420   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83421   unsigned int arg2 ;
83422   float arg3 ;
83423
83424   arg1 = (Dali::Toolkit::TableView *)jarg1;
83425   arg2 = (unsigned int)jarg2;
83426   arg3 = (float)jarg3;
83427   {
83428     try {
83429       (arg1)->SetRelativeWidth(arg2,arg3);
83430     } catch (std::out_of_range& e) {
83431       {
83432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83433       };
83434     } catch (std::exception& e) {
83435       {
83436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83437       };
83438     } catch (Dali::DaliException e) {
83439       {
83440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83441       };
83442     } catch (...) {
83443       {
83444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83445       };
83446     }
83447   }
83448
83449 }
83450
83451
83452 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83453   float jresult ;
83454   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83455   unsigned int arg2 ;
83456   float result;
83457
83458   arg1 = (Dali::Toolkit::TableView *)jarg1;
83459   arg2 = (unsigned int)jarg2;
83460   {
83461     try {
83462       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83463     } catch (std::out_of_range& e) {
83464       {
83465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83466       };
83467     } catch (std::exception& e) {
83468       {
83469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83470       };
83471     } catch (Dali::DaliException e) {
83472       {
83473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83474       };
83475     } catch (...) {
83476       {
83477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83478       };
83479     }
83480   }
83481
83482   jresult = result;
83483   return jresult;
83484 }
83485
83486
83487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83488   unsigned int jresult ;
83489   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83490   unsigned int result;
83491
83492   arg1 = (Dali::Toolkit::TableView *)jarg1;
83493   {
83494     try {
83495       result = (unsigned int)(arg1)->GetRows();
83496     } catch (std::out_of_range& e) {
83497       {
83498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83499       };
83500     } catch (std::exception& e) {
83501       {
83502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83503       };
83504     } catch (Dali::DaliException e) {
83505       {
83506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83507       };
83508     } catch (...) {
83509       {
83510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83511       };
83512     }
83513   }
83514
83515   jresult = result;
83516   return jresult;
83517 }
83518
83519
83520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83521   unsigned int jresult ;
83522   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83523   unsigned int result;
83524
83525   arg1 = (Dali::Toolkit::TableView *)jarg1;
83526   {
83527     try {
83528       result = (unsigned int)(arg1)->GetColumns();
83529     } catch (std::out_of_range& e) {
83530       {
83531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83532       };
83533     } catch (std::exception& e) {
83534       {
83535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83536       };
83537     } catch (Dali::DaliException e) {
83538       {
83539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83540       };
83541     } catch (...) {
83542       {
83543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83544       };
83545     }
83546   }
83547
83548   jresult = result;
83549   return jresult;
83550 }
83551
83552
83553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83554   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83555   Dali::Toolkit::TableView::CellPosition arg2 ;
83556   Dali::HorizontalAlignment::Type arg3 ;
83557   Dali::VerticalAlignment::Type arg4 ;
83558   Dali::Toolkit::TableView::CellPosition *argp2 ;
83559
83560   arg1 = (Dali::Toolkit::TableView *)jarg1;
83561   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83562   if (!argp2) {
83563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83564     return ;
83565   }
83566   arg2 = *argp2;
83567   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83568   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83569   {
83570     try {
83571       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83572     } catch (std::out_of_range& e) {
83573       {
83574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83575       };
83576     } catch (std::exception& e) {
83577       {
83578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83579       };
83580     } catch (Dali::DaliException e) {
83581       {
83582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83583       };
83584     } catch (...) {
83585       {
83586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83587       };
83588     }
83589   }
83590
83591 }
83592
83593
83594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83595   unsigned int jresult ;
83596   unsigned int result;
83597
83598   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83599   jresult = result;
83600   return jresult;
83601 }
83602
83603
83604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83605   int jresult ;
83606   int result;
83607
83608   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83609   jresult = (int)result;
83610   return jresult;
83611 }
83612
83613
83614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83615   int jresult ;
83616   int result;
83617
83618   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83619   jresult = (int)result;
83620   return jresult;
83621 }
83622
83623
83624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83625   int jresult ;
83626   int result;
83627
83628   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83629   jresult = (int)result;
83630   return jresult;
83631 }
83632
83633
83634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83635   int jresult ;
83636   int result;
83637
83638   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83639   jresult = (int)result;
83640   return jresult;
83641 }
83642
83643
83644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83645   int jresult ;
83646   int result;
83647
83648   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83649   jresult = (int)result;
83650   return jresult;
83651 }
83652
83653
83654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83655   int jresult ;
83656   int result;
83657
83658   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83659   jresult = (int)result;
83660   return jresult;
83661 }
83662
83663
83664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83665   int jresult ;
83666   int result;
83667
83668   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83669   jresult = (int)result;
83670   return jresult;
83671 }
83672
83673
83674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83675   int jresult ;
83676   int result;
83677
83678   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83679   jresult = (int)result;
83680   return jresult;
83681 }
83682
83683
83684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83685   int jresult ;
83686   int result;
83687
83688   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83689   jresult = (int)result;
83690   return jresult;
83691 }
83692
83693
83694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83695   int jresult ;
83696   int result;
83697
83698   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83699   jresult = (int)result;
83700   return jresult;
83701 }
83702
83703
83704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
83705   int jresult ;
83706   int result;
83707
83708   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
83709   jresult = (int)result;
83710   return jresult;
83711 }
83712
83713
83714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
83715   int jresult ;
83716   int result;
83717
83718   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
83719   jresult = (int)result;
83720   return jresult;
83721 }
83722
83723
83724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
83725   int jresult ;
83726   int result;
83727
83728   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
83729   jresult = (int)result;
83730   return jresult;
83731 }
83732
83733
83734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
83735   int jresult ;
83736   int result;
83737
83738   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
83739   jresult = (int)result;
83740   return jresult;
83741 }
83742
83743
83744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
83745   int jresult ;
83746   int result;
83747
83748   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
83749   jresult = (int)result;
83750   return jresult;
83751 }
83752
83753
83754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
83755   int jresult ;
83756   int result;
83757
83758   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
83759   jresult = (int)result;
83760   return jresult;
83761 }
83762
83763
83764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
83765   int jresult ;
83766   int result;
83767
83768   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
83769   jresult = (int)result;
83770   return jresult;
83771 }
83772
83773
83774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
83775   int jresult ;
83776   int result;
83777
83778   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
83779   jresult = (int)result;
83780   return jresult;
83781 }
83782
83783
83784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
83785   int jresult ;
83786   int result;
83787
83788   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
83789   jresult = (int)result;
83790   return jresult;
83791 }
83792
83793
83794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
83795   void * jresult ;
83796   Dali::Toolkit::TextLabel::Property *result = 0 ;
83797
83798   {
83799     try {
83800       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
83801     } catch (std::out_of_range& e) {
83802       {
83803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83804       };
83805     } catch (std::exception& e) {
83806       {
83807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83808       };
83809     } catch (Dali::DaliException e) {
83810       {
83811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83812       };
83813     } catch (...) {
83814       {
83815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83816       };
83817     }
83818   }
83819
83820   jresult = (void *)result;
83821   return jresult;
83822 }
83823
83824
83825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
83826   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
83827
83828   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
83829   {
83830     try {
83831       delete arg1;
83832     } catch (std::out_of_range& e) {
83833       {
83834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83835       };
83836     } catch (std::exception& e) {
83837       {
83838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83839       };
83840     } catch (Dali::DaliException e) {
83841       {
83842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83843       };
83844     } catch (...) {
83845       {
83846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83847       };
83848     }
83849   }
83850
83851 }
83852
83853
83854 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83855   void * jresult ;
83856   Dali::Toolkit::TextLabel result;
83857
83858   {
83859     try {
83860       result = Dali::Toolkit::TextLabel::New();
83861     } catch (std::out_of_range& e) {
83862       {
83863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83864       };
83865     } catch (std::exception& e) {
83866       {
83867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83868       };
83869     } catch (Dali::DaliException e) {
83870       {
83871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83872       };
83873     } catch (...) {
83874       {
83875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83876       };
83877     }
83878   }
83879
83880   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83881   return jresult;
83882 }
83883
83884
83885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83886   void * jresult ;
83887   std::string *arg1 = 0 ;
83888   Dali::Toolkit::TextLabel result;
83889
83890   if (!jarg1) {
83891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83892     return 0;
83893   }
83894   std::string arg1_str(jarg1);
83895   arg1 = &arg1_str;
83896   {
83897     try {
83898       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
83899     } catch (std::out_of_range& e) {
83900       {
83901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83902       };
83903     } catch (std::exception& e) {
83904       {
83905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83906       };
83907     } catch (Dali::DaliException e) {
83908       {
83909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83910       };
83911     } catch (...) {
83912       {
83913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83914       };
83915     }
83916   }
83917
83918   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83919
83920   //argout typemap for const std::string&
83921
83922   return jresult;
83923 }
83924
83925
83926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83927   void * jresult ;
83928   Dali::Toolkit::TextLabel *result = 0 ;
83929
83930   {
83931     try {
83932       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83933     } catch (std::out_of_range& e) {
83934       {
83935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83936       };
83937     } catch (std::exception& e) {
83938       {
83939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83940       };
83941     } catch (Dali::DaliException e) {
83942       {
83943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83944       };
83945     } catch (...) {
83946       {
83947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83948       };
83949     }
83950   }
83951
83952   jresult = (void *)result;
83953   return jresult;
83954 }
83955
83956
83957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83958   void * jresult ;
83959   Dali::Toolkit::TextLabel *arg1 = 0 ;
83960   Dali::Toolkit::TextLabel *result = 0 ;
83961
83962   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83963   if (!arg1) {
83964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83965     return 0;
83966   }
83967   {
83968     try {
83969       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83970     } catch (std::out_of_range& e) {
83971       {
83972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83973       };
83974     } catch (std::exception& e) {
83975       {
83976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83977       };
83978     } catch (Dali::DaliException e) {
83979       {
83980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83981       };
83982     } catch (...) {
83983       {
83984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83985       };
83986     }
83987   }
83988
83989   jresult = (void *)result;
83990   return jresult;
83991 }
83992
83993
83994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83995   void * jresult ;
83996   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83997   Dali::Toolkit::TextLabel *arg2 = 0 ;
83998   Dali::Toolkit::TextLabel *result = 0 ;
83999
84000   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84001   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
84002   if (!arg2) {
84003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
84004     return 0;
84005   }
84006   {
84007     try {
84008       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
84009     } catch (std::out_of_range& e) {
84010       {
84011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84012       };
84013     } catch (std::exception& e) {
84014       {
84015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84016       };
84017     } catch (Dali::DaliException e) {
84018       {
84019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84020       };
84021     } catch (...) {
84022       {
84023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84024       };
84025     }
84026   }
84027
84028   jresult = (void *)result;
84029   return jresult;
84030 }
84031
84032
84033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
84034   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
84035
84036   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
84037   {
84038     try {
84039       delete arg1;
84040     } catch (std::out_of_range& e) {
84041       {
84042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84043       };
84044     } catch (std::exception& e) {
84045       {
84046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84047       };
84048     } catch (Dali::DaliException e) {
84049       {
84050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84051       };
84052     } catch (...) {
84053       {
84054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84055       };
84056     }
84057   }
84058
84059 }
84060
84061
84062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84063   void * jresult ;
84064   Dali::BaseHandle arg1 ;
84065   Dali::BaseHandle *argp1 ;
84066   Dali::Toolkit::TextLabel result;
84067
84068   argp1 = (Dali::BaseHandle *)jarg1;
84069   if (!argp1) {
84070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84071     return 0;
84072   }
84073   arg1 = *argp1;
84074   {
84075     try {
84076       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84077     } catch (std::out_of_range& e) {
84078       {
84079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84080       };
84081     } catch (std::exception& e) {
84082       {
84083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84084       };
84085     } catch (Dali::DaliException e) {
84086       {
84087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84088       };
84089     } catch (...) {
84090       {
84091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84092       };
84093     }
84094   }
84095
84096   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84097   return jresult;
84098 }
84099
84100
84101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84102   void * jresult ;
84103   Dali::Toolkit::AccessibilityManager *result = 0 ;
84104
84105   {
84106     try {
84107       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84108     } catch (std::out_of_range& e) {
84109       {
84110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84111       };
84112     } catch (std::exception& e) {
84113       {
84114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84115       };
84116     } catch (Dali::DaliException e) {
84117       {
84118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84119       };
84120     } catch (...) {
84121       {
84122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84123       };
84124     }
84125   }
84126
84127   jresult = (void *)result;
84128   return jresult;
84129 }
84130
84131
84132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84133   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84134
84135   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84136   {
84137     try {
84138       delete arg1;
84139     } catch (std::out_of_range& e) {
84140       {
84141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84142       };
84143     } catch (std::exception& e) {
84144       {
84145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84146       };
84147     } catch (Dali::DaliException e) {
84148       {
84149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84150       };
84151     } catch (...) {
84152       {
84153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84154       };
84155     }
84156   }
84157
84158 }
84159
84160
84161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84162   void * jresult ;
84163   Dali::Toolkit::AccessibilityManager result;
84164
84165   {
84166     try {
84167       result = Dali::Toolkit::AccessibilityManager::Get();
84168     } catch (std::out_of_range& e) {
84169       {
84170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84171       };
84172     } catch (std::exception& e) {
84173       {
84174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84175       };
84176     } catch (Dali::DaliException e) {
84177       {
84178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84179       };
84180     } catch (...) {
84181       {
84182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84183       };
84184     }
84185   }
84186
84187   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84188   return jresult;
84189 }
84190
84191
84192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84193   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84194   Dali::Actor arg2 ;
84195   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84196   std::string *arg4 = 0 ;
84197   Dali::Actor *argp2 ;
84198
84199   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84200   argp2 = (Dali::Actor *)jarg2;
84201   if (!argp2) {
84202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84203     return ;
84204   }
84205   arg2 = *argp2;
84206   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84207   if (!jarg4) {
84208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84209     return ;
84210   }
84211   std::string arg4_str(jarg4);
84212   arg4 = &arg4_str;
84213   {
84214     try {
84215       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84216     } catch (std::out_of_range& e) {
84217       {
84218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84219       };
84220     } catch (std::exception& e) {
84221       {
84222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84223       };
84224     } catch (Dali::DaliException e) {
84225       {
84226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84227       };
84228     } catch (...) {
84229       {
84230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84231       };
84232     }
84233   }
84234
84235
84236   //argout typemap for const std::string&
84237
84238 }
84239
84240
84241 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84242   char * jresult ;
84243   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84244   Dali::Actor arg2 ;
84245   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84246   Dali::Actor *argp2 ;
84247   std::string result;
84248
84249   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84250   argp2 = (Dali::Actor *)jarg2;
84251   if (!argp2) {
84252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84253     return 0;
84254   }
84255   arg2 = *argp2;
84256   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84257   {
84258     try {
84259       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84260     } catch (std::out_of_range& e) {
84261       {
84262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84263       };
84264     } catch (std::exception& e) {
84265       {
84266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84267       };
84268     } catch (Dali::DaliException e) {
84269       {
84270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84271       };
84272     } catch (...) {
84273       {
84274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84275       };
84276     }
84277   }
84278
84279   jresult = SWIG_csharp_string_callback((&result)->c_str());
84280   return jresult;
84281 }
84282
84283
84284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84285   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84286   Dali::Actor arg2 ;
84287   unsigned int arg3 ;
84288   Dali::Actor *argp2 ;
84289
84290   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84291   argp2 = (Dali::Actor *)jarg2;
84292   if (!argp2) {
84293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84294     return ;
84295   }
84296   arg2 = *argp2;
84297   arg3 = (unsigned int)jarg3;
84298   {
84299     try {
84300       (arg1)->SetFocusOrder(arg2,arg3);
84301     } catch (std::out_of_range& e) {
84302       {
84303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84304       };
84305     } catch (std::exception& e) {
84306       {
84307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84308       };
84309     } catch (Dali::DaliException e) {
84310       {
84311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84312       };
84313     } catch (...) {
84314       {
84315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84316       };
84317     }
84318   }
84319
84320 }
84321
84322
84323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84324   unsigned int jresult ;
84325   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84326   Dali::Actor arg2 ;
84327   Dali::Actor *argp2 ;
84328   unsigned int result;
84329
84330   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84331   argp2 = (Dali::Actor *)jarg2;
84332   if (!argp2) {
84333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84334     return 0;
84335   }
84336   arg2 = *argp2;
84337   {
84338     try {
84339       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84340     } catch (std::out_of_range& e) {
84341       {
84342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84343       };
84344     } catch (std::exception& e) {
84345       {
84346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84347       };
84348     } catch (Dali::DaliException e) {
84349       {
84350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84351       };
84352     } catch (...) {
84353       {
84354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84355       };
84356     }
84357   }
84358
84359   jresult = result;
84360   return jresult;
84361 }
84362
84363
84364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84365   unsigned int jresult ;
84366   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84367   unsigned int result;
84368
84369   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84370   {
84371     try {
84372       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84373     } catch (std::out_of_range& e) {
84374       {
84375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84376       };
84377     } catch (std::exception& e) {
84378       {
84379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84380       };
84381     } catch (Dali::DaliException e) {
84382       {
84383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84384       };
84385     } catch (...) {
84386       {
84387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84388       };
84389     }
84390   }
84391
84392   jresult = result;
84393   return jresult;
84394 }
84395
84396
84397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84398   void * jresult ;
84399   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84400   unsigned int arg2 ;
84401   Dali::Actor result;
84402
84403   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84404   arg2 = (unsigned int)jarg2;
84405   {
84406     try {
84407       result = (arg1)->GetActorByFocusOrder(arg2);
84408     } catch (std::out_of_range& e) {
84409       {
84410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84411       };
84412     } catch (std::exception& e) {
84413       {
84414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84415       };
84416     } catch (Dali::DaliException e) {
84417       {
84418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84419       };
84420     } catch (...) {
84421       {
84422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84423       };
84424     }
84425   }
84426
84427   jresult = new Dali::Actor((const Dali::Actor &)result);
84428   return jresult;
84429 }
84430
84431
84432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84433   unsigned int jresult ;
84434   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84435   Dali::Actor arg2 ;
84436   Dali::Actor *argp2 ;
84437   bool result;
84438
84439   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84440   argp2 = (Dali::Actor *)jarg2;
84441   if (!argp2) {
84442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84443     return 0;
84444   }
84445   arg2 = *argp2;
84446   {
84447     try {
84448       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84449     } catch (std::out_of_range& e) {
84450       {
84451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84452       };
84453     } catch (std::exception& e) {
84454       {
84455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84456       };
84457     } catch (Dali::DaliException e) {
84458       {
84459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84460       };
84461     } catch (...) {
84462       {
84463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84464       };
84465     }
84466   }
84467
84468   jresult = result;
84469   return jresult;
84470 }
84471
84472
84473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84474   void * jresult ;
84475   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84476   Dali::Actor result;
84477
84478   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84479   {
84480     try {
84481       result = (arg1)->GetCurrentFocusActor();
84482     } catch (std::out_of_range& e) {
84483       {
84484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84485       };
84486     } catch (std::exception& e) {
84487       {
84488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84489       };
84490     } catch (Dali::DaliException e) {
84491       {
84492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84493       };
84494     } catch (...) {
84495       {
84496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84497       };
84498     }
84499   }
84500
84501   jresult = new Dali::Actor((const Dali::Actor &)result);
84502   return jresult;
84503 }
84504
84505
84506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84507   void * jresult ;
84508   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84509   Dali::Actor result;
84510
84511   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84512   {
84513     try {
84514       result = (arg1)->GetCurrentFocusGroup();
84515     } catch (std::out_of_range& e) {
84516       {
84517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84518       };
84519     } catch (std::exception& e) {
84520       {
84521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84522       };
84523     } catch (Dali::DaliException e) {
84524       {
84525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84526       };
84527     } catch (...) {
84528       {
84529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84530       };
84531     }
84532   }
84533
84534   jresult = new Dali::Actor((const Dali::Actor &)result);
84535   return jresult;
84536 }
84537
84538
84539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84540   unsigned int jresult ;
84541   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84542   unsigned int result;
84543
84544   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84545   {
84546     try {
84547       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84548     } catch (std::out_of_range& e) {
84549       {
84550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84551       };
84552     } catch (std::exception& e) {
84553       {
84554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84555       };
84556     } catch (Dali::DaliException e) {
84557       {
84558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84559       };
84560     } catch (...) {
84561       {
84562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84563       };
84564     }
84565   }
84566
84567   jresult = result;
84568   return jresult;
84569 }
84570
84571
84572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84573   unsigned int jresult ;
84574   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84575   bool result;
84576
84577   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84578   {
84579     try {
84580       result = (bool)(arg1)->MoveFocusForward();
84581     } catch (std::out_of_range& e) {
84582       {
84583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84584       };
84585     } catch (std::exception& e) {
84586       {
84587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84588       };
84589     } catch (Dali::DaliException e) {
84590       {
84591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84592       };
84593     } catch (...) {
84594       {
84595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84596       };
84597     }
84598   }
84599
84600   jresult = result;
84601   return jresult;
84602 }
84603
84604
84605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84606   unsigned int jresult ;
84607   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84608   bool result;
84609
84610   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84611   {
84612     try {
84613       result = (bool)(arg1)->MoveFocusBackward();
84614     } catch (std::out_of_range& e) {
84615       {
84616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84617       };
84618     } catch (std::exception& e) {
84619       {
84620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84621       };
84622     } catch (Dali::DaliException e) {
84623       {
84624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84625       };
84626     } catch (...) {
84627       {
84628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84629       };
84630     }
84631   }
84632
84633   jresult = result;
84634   return jresult;
84635 }
84636
84637
84638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84639   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84640
84641   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84642   {
84643     try {
84644       (arg1)->ClearFocus();
84645     } catch (std::out_of_range& e) {
84646       {
84647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84648       };
84649     } catch (std::exception& e) {
84650       {
84651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84652       };
84653     } catch (Dali::DaliException e) {
84654       {
84655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84656       };
84657     } catch (...) {
84658       {
84659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84660       };
84661     }
84662   }
84663
84664 }
84665
84666
84667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84668   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84669
84670   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84671   {
84672     try {
84673       (arg1)->Reset();
84674     } catch (std::out_of_range& e) {
84675       {
84676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84677       };
84678     } catch (std::exception& e) {
84679       {
84680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84681       };
84682     } catch (Dali::DaliException e) {
84683       {
84684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84685       };
84686     } catch (...) {
84687       {
84688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84689       };
84690     }
84691   }
84692
84693 }
84694
84695
84696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84697   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84698   Dali::Actor arg2 ;
84699   bool arg3 ;
84700   Dali::Actor *argp2 ;
84701
84702   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84703   argp2 = (Dali::Actor *)jarg2;
84704   if (!argp2) {
84705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84706     return ;
84707   }
84708   arg2 = *argp2;
84709   arg3 = jarg3 ? true : false;
84710   {
84711     try {
84712       (arg1)->SetFocusGroup(arg2,arg3);
84713     } catch (std::out_of_range& e) {
84714       {
84715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84716       };
84717     } catch (std::exception& e) {
84718       {
84719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84720       };
84721     } catch (Dali::DaliException e) {
84722       {
84723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84724       };
84725     } catch (...) {
84726       {
84727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84728       };
84729     }
84730   }
84731
84732 }
84733
84734
84735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
84736   unsigned int jresult ;
84737   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84738   Dali::Actor arg2 ;
84739   Dali::Actor *argp2 ;
84740   bool result;
84741
84742   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84743   argp2 = (Dali::Actor *)jarg2;
84744   if (!argp2) {
84745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84746     return 0;
84747   }
84748   arg2 = *argp2;
84749   {
84750     try {
84751       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
84752     } catch (std::out_of_range& e) {
84753       {
84754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84755       };
84756     } catch (std::exception& e) {
84757       {
84758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84759       };
84760     } catch (Dali::DaliException e) {
84761       {
84762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84763       };
84764     } catch (...) {
84765       {
84766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84767       };
84768     }
84769   }
84770
84771   jresult = result;
84772   return jresult;
84773 }
84774
84775
84776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
84777   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84778   bool arg2 ;
84779
84780   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84781   arg2 = jarg2 ? true : false;
84782   {
84783     try {
84784       (arg1)->SetGroupMode(arg2);
84785     } catch (std::out_of_range& e) {
84786       {
84787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84788       };
84789     } catch (std::exception& e) {
84790       {
84791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84792       };
84793     } catch (Dali::DaliException e) {
84794       {
84795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84796       };
84797     } catch (...) {
84798       {
84799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84800       };
84801     }
84802   }
84803
84804 }
84805
84806
84807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
84808   unsigned int jresult ;
84809   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84810   bool result;
84811
84812   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84813   {
84814     try {
84815       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
84816     } catch (std::out_of_range& e) {
84817       {
84818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84819       };
84820     } catch (std::exception& e) {
84821       {
84822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84823       };
84824     } catch (Dali::DaliException e) {
84825       {
84826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84827       };
84828     } catch (...) {
84829       {
84830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84831       };
84832     }
84833   }
84834
84835   jresult = result;
84836   return jresult;
84837 }
84838
84839
84840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
84841   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84842   bool arg2 ;
84843
84844   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84845   arg2 = jarg2 ? true : false;
84846   {
84847     try {
84848       (arg1)->SetWrapMode(arg2);
84849     } catch (std::out_of_range& e) {
84850       {
84851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84852       };
84853     } catch (std::exception& e) {
84854       {
84855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84856       };
84857     } catch (Dali::DaliException e) {
84858       {
84859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84860       };
84861     } catch (...) {
84862       {
84863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84864       };
84865     }
84866   }
84867
84868 }
84869
84870
84871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84872   unsigned int jresult ;
84873   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84874   bool result;
84875
84876   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84877   {
84878     try {
84879       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84880     } catch (std::out_of_range& e) {
84881       {
84882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84883       };
84884     } catch (std::exception& e) {
84885       {
84886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84887       };
84888     } catch (Dali::DaliException e) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84891       };
84892     } catch (...) {
84893       {
84894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84895       };
84896     }
84897   }
84898
84899   jresult = result;
84900   return jresult;
84901 }
84902
84903
84904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84906   Dali::Actor arg2 ;
84907   Dali::Actor *argp2 ;
84908
84909   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84910   argp2 = (Dali::Actor *)jarg2;
84911   if (!argp2) {
84912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84913     return ;
84914   }
84915   arg2 = *argp2;
84916   {
84917     try {
84918       (arg1)->SetFocusIndicatorActor(arg2);
84919     } catch (std::out_of_range& e) {
84920       {
84921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84922       };
84923     } catch (std::exception& e) {
84924       {
84925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84926       };
84927     } catch (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
84940
84941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84942   void * jresult ;
84943   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84944   Dali::Actor result;
84945
84946   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84947   {
84948     try {
84949       result = (arg1)->GetFocusIndicatorActor();
84950     } catch (std::out_of_range& e) {
84951       {
84952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84953       };
84954     } catch (std::exception& e) {
84955       {
84956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84957       };
84958     } catch (Dali::DaliException e) {
84959       {
84960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84961       };
84962     } catch (...) {
84963       {
84964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84965       };
84966     }
84967   }
84968
84969   jresult = new Dali::Actor((const Dali::Actor &)result);
84970   return jresult;
84971 }
84972
84973
84974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84975   void * jresult ;
84976   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84977   Dali::Actor arg2 ;
84978   Dali::Actor *argp2 ;
84979   Dali::Actor result;
84980
84981   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84982   argp2 = (Dali::Actor *)jarg2;
84983   if (!argp2) {
84984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84985     return 0;
84986   }
84987   arg2 = *argp2;
84988   {
84989     try {
84990       result = (arg1)->GetFocusGroup(arg2);
84991     } catch (std::out_of_range& e) {
84992       {
84993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84994       };
84995     } catch (std::exception& e) {
84996       {
84997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84998       };
84999     } catch (Dali::DaliException e) {
85000       {
85001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85002       };
85003     } catch (...) {
85004       {
85005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85006       };
85007     }
85008   }
85009
85010   jresult = new Dali::Actor((const Dali::Actor &)result);
85011   return jresult;
85012 }
85013
85014
85015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
85016   void * jresult ;
85017   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85018   Dali::Vector2 result;
85019
85020   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85021   {
85022     try {
85023       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
85024     } catch (std::out_of_range& e) {
85025       {
85026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85027       };
85028     } catch (std::exception& e) {
85029       {
85030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85031       };
85032     } catch (Dali::DaliException e) {
85033       {
85034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85035       };
85036     } catch (...) {
85037       {
85038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85039       };
85040     }
85041   }
85042
85043   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85044   return jresult;
85045 }
85046
85047
85048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85049   void * jresult ;
85050   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85051   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85052
85053   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85054   {
85055     try {
85056       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85057     } catch (std::out_of_range& e) {
85058       {
85059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85060       };
85061     } catch (std::exception& e) {
85062       {
85063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85064       };
85065     } catch (Dali::DaliException e) {
85066       {
85067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85068       };
85069     } catch (...) {
85070       {
85071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85072       };
85073     }
85074   }
85075
85076   jresult = (void *)result;
85077   return jresult;
85078 }
85079
85080
85081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85082   void * jresult ;
85083   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85084   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85085
85086   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85087   {
85088     try {
85089       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85090     } catch (std::out_of_range& e) {
85091       {
85092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85093       };
85094     } catch (std::exception& e) {
85095       {
85096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85097       };
85098     } catch (Dali::DaliException e) {
85099       {
85100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85101       };
85102     } catch (...) {
85103       {
85104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85105       };
85106     }
85107   }
85108
85109   jresult = (void *)result;
85110   return jresult;
85111 }
85112
85113
85114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85115   void * jresult ;
85116   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85117   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85118
85119   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85120   {
85121     try {
85122       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85123     } catch (std::out_of_range& e) {
85124       {
85125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85126       };
85127     } catch (std::exception& e) {
85128       {
85129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85130       };
85131     } catch (Dali::DaliException e) {
85132       {
85133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85134       };
85135     } catch (...) {
85136       {
85137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85138       };
85139     }
85140   }
85141
85142   jresult = (void *)result;
85143   return jresult;
85144 }
85145
85146
85147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85148   void * jresult ;
85149   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85150   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85151
85152   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85153   {
85154     try {
85155       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85156     } catch (std::out_of_range& e) {
85157       {
85158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85159       };
85160     } catch (std::exception& e) {
85161       {
85162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85163       };
85164     } catch (Dali::DaliException e) {
85165       {
85166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85167       };
85168     } catch (...) {
85169       {
85170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85171       };
85172     }
85173   }
85174
85175   jresult = (void *)result;
85176   return jresult;
85177 }
85178
85179
85180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85181   void * jresult ;
85182   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85183   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85184
85185   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85186   {
85187     try {
85188       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85189     } catch (std::out_of_range& e) {
85190       {
85191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85192       };
85193     } catch (std::exception& e) {
85194       {
85195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85196       };
85197     } catch (Dali::DaliException e) {
85198       {
85199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85200       };
85201     } catch (...) {
85202       {
85203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85204       };
85205     }
85206   }
85207
85208   jresult = (void *)result;
85209   return jresult;
85210 }
85211
85212
85213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85214   void * jresult ;
85215   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85216   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85217
85218   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85219   {
85220     try {
85221       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85222     } catch (std::out_of_range& e) {
85223       {
85224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85225       };
85226     } catch (std::exception& e) {
85227       {
85228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85229       };
85230     } catch (Dali::DaliException e) {
85231       {
85232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85233       };
85234     } catch (...) {
85235       {
85236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85237       };
85238     }
85239   }
85240
85241   jresult = (void *)result;
85242   return jresult;
85243 }
85244
85245
85246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85247   void * jresult ;
85248   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85249   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85250
85251   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85252   {
85253     try {
85254       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85255     } catch (std::out_of_range& e) {
85256       {
85257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85258       };
85259     } catch (std::exception& e) {
85260       {
85261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85262       };
85263     } catch (Dali::DaliException e) {
85264       {
85265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85266       };
85267     } catch (...) {
85268       {
85269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85270       };
85271     }
85272   }
85273
85274   jresult = (void *)result;
85275   return jresult;
85276 }
85277
85278
85279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85280   void * jresult ;
85281   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85282   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85283
85284   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85285   {
85286     try {
85287       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85288     } catch (std::out_of_range& e) {
85289       {
85290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85291       };
85292     } catch (std::exception& e) {
85293       {
85294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85295       };
85296     } catch (Dali::DaliException e) {
85297       {
85298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85299       };
85300     } catch (...) {
85301       {
85302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85303       };
85304     }
85305   }
85306
85307   jresult = (void *)result;
85308   return jresult;
85309 }
85310
85311
85312 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85313   void * jresult ;
85314   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85315   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85316
85317   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85318   {
85319     try {
85320       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85321     } catch (std::out_of_range& e) {
85322       {
85323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85324       };
85325     } catch (std::exception& e) {
85326       {
85327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85328       };
85329     } catch (Dali::DaliException e) {
85330       {
85331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85332       };
85333     } catch (...) {
85334       {
85335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85336       };
85337     }
85338   }
85339
85340   jresult = (void *)result;
85341   return jresult;
85342 }
85343
85344
85345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85346   void * jresult ;
85347   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85348   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85349
85350   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85351   {
85352     try {
85353       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85354     } catch (std::out_of_range& e) {
85355       {
85356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85357       };
85358     } catch (std::exception& e) {
85359       {
85360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85361       };
85362     } catch (Dali::DaliException e) {
85363       {
85364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85365       };
85366     } catch (...) {
85367       {
85368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85369       };
85370     }
85371   }
85372
85373   jresult = (void *)result;
85374   return jresult;
85375 }
85376
85377
85378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85379   void * jresult ;
85380   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85381   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85382
85383   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85384   {
85385     try {
85386       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85387     } catch (std::out_of_range& e) {
85388       {
85389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85390       };
85391     } catch (std::exception& e) {
85392       {
85393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85394       };
85395     } catch (Dali::DaliException e) {
85396       {
85397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85398       };
85399     } catch (...) {
85400       {
85401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85402       };
85403     }
85404   }
85405
85406   jresult = (void *)result;
85407   return jresult;
85408 }
85409
85410
85411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85412   void * jresult ;
85413   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85414   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85415
85416   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85417   {
85418     try {
85419       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85420     } catch (std::out_of_range& e) {
85421       {
85422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85423       };
85424     } catch (std::exception& e) {
85425       {
85426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85427       };
85428     } catch (Dali::DaliException e) {
85429       {
85430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85431       };
85432     } catch (...) {
85433       {
85434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85435       };
85436     }
85437   }
85438
85439   jresult = (void *)result;
85440   return jresult;
85441 }
85442
85443
85444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85445   void * jresult ;
85446   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85447   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85448
85449   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85450   {
85451     try {
85452       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85453     } catch (std::out_of_range& e) {
85454       {
85455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85456       };
85457     } catch (std::exception& e) {
85458       {
85459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85460       };
85461     } catch (Dali::DaliException e) {
85462       {
85463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85464       };
85465     } catch (...) {
85466       {
85467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85468       };
85469     }
85470   }
85471
85472   jresult = (void *)result;
85473   return jresult;
85474 }
85475
85476
85477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85478   void * jresult ;
85479   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85480   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85481
85482   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85483   {
85484     try {
85485       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85486     } catch (std::out_of_range& e) {
85487       {
85488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85489       };
85490     } catch (std::exception& e) {
85491       {
85492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85493       };
85494     } catch (Dali::DaliException e) {
85495       {
85496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85497       };
85498     } catch (...) {
85499       {
85500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85501       };
85502     }
85503   }
85504
85505   jresult = (void *)result;
85506   return jresult;
85507 }
85508
85509
85510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85511   void * jresult ;
85512   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85513   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85514
85515   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85516   {
85517     try {
85518       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
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 = (void *)result;
85539   return jresult;
85540 }
85541
85542
85543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85544   void * jresult ;
85545   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85546   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85547
85548   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85549   {
85550     try {
85551       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85552     } catch (std::out_of_range& e) {
85553       {
85554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85555       };
85556     } catch (std::exception& e) {
85557       {
85558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85559       };
85560     } catch (Dali::DaliException e) {
85561       {
85562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85563       };
85564     } catch (...) {
85565       {
85566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85567       };
85568     }
85569   }
85570
85571   jresult = (void *)result;
85572   return jresult;
85573 }
85574
85575
85576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85577   void * jresult ;
85578   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85579   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85580
85581   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85582   {
85583     try {
85584       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85585     } catch (std::out_of_range& e) {
85586       {
85587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85588       };
85589     } catch (std::exception& e) {
85590       {
85591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85592       };
85593     } catch (Dali::DaliException e) {
85594       {
85595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85596       };
85597     } catch (...) {
85598       {
85599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85600       };
85601     }
85602   }
85603
85604   jresult = (void *)result;
85605   return jresult;
85606 }
85607
85608
85609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85610   void * jresult ;
85611   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85612   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85613
85614   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85615   {
85616     try {
85617       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85618     } catch (std::out_of_range& e) {
85619       {
85620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85621       };
85622     } catch (std::exception& e) {
85623       {
85624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85625       };
85626     } catch (Dali::DaliException e) {
85627       {
85628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85629       };
85630     } catch (...) {
85631       {
85632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85633       };
85634     }
85635   }
85636
85637   jresult = (void *)result;
85638   return jresult;
85639 }
85640
85641
85642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85643   void * jresult ;
85644   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85645   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85646
85647   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85648   {
85649     try {
85650       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85651     } catch (std::out_of_range& e) {
85652       {
85653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85654       };
85655     } catch (std::exception& e) {
85656       {
85657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85658       };
85659     } catch (Dali::DaliException e) {
85660       {
85661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85662       };
85663     } catch (...) {
85664       {
85665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85666       };
85667     }
85668   }
85669
85670   jresult = (void *)result;
85671   return jresult;
85672 }
85673
85674
85675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85676   void * jresult ;
85677   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85678   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85679
85680   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85681   {
85682     try {
85683       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85684     } catch (std::out_of_range& e) {
85685       {
85686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85687       };
85688     } catch (std::exception& e) {
85689       {
85690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85691       };
85692     } catch (Dali::DaliException e) {
85693       {
85694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85695       };
85696     } catch (...) {
85697       {
85698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85699       };
85700     }
85701   }
85702
85703   jresult = (void *)result;
85704   return jresult;
85705 }
85706
85707
85708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
85709   void * jresult ;
85710   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85711   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85712
85713   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85714   {
85715     try {
85716       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
85717     } catch (std::out_of_range& e) {
85718       {
85719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85720       };
85721     } catch (std::exception& e) {
85722       {
85723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85724       };
85725     } catch (Dali::DaliException e) {
85726       {
85727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85728       };
85729     } catch (...) {
85730       {
85731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85732       };
85733     }
85734   }
85735
85736   jresult = (void *)result;
85737   return jresult;
85738 }
85739
85740
85741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
85742   void * jresult ;
85743   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85744   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85745
85746   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85747   {
85748     try {
85749       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
85750     } catch (std::out_of_range& e) {
85751       {
85752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85753       };
85754     } catch (std::exception& e) {
85755       {
85756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85757       };
85758     } catch (Dali::DaliException e) {
85759       {
85760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85761       };
85762     } catch (...) {
85763       {
85764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85765       };
85766     }
85767   }
85768
85769   jresult = (void *)result;
85770   return jresult;
85771 }
85772
85773
85774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
85775   void * jresult ;
85776   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85777   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85778
85779   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85780   {
85781     try {
85782       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
85783     } catch (std::out_of_range& e) {
85784       {
85785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85786       };
85787     } catch (std::exception& e) {
85788       {
85789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85790       };
85791     } catch (Dali::DaliException e) {
85792       {
85793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85794       };
85795     } catch (...) {
85796       {
85797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85798       };
85799     }
85800   }
85801
85802   jresult = (void *)result;
85803   return jresult;
85804 }
85805
85806
85807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
85808   void * jresult ;
85809   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85810   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85811
85812   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85813   {
85814     try {
85815       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
85816     } catch (std::out_of_range& e) {
85817       {
85818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85819       };
85820     } catch (std::exception& e) {
85821       {
85822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85823       };
85824     } catch (Dali::DaliException e) {
85825       {
85826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85827       };
85828     } catch (...) {
85829       {
85830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85831       };
85832     }
85833   }
85834
85835   jresult = (void *)result;
85836   return jresult;
85837 }
85838
85839
85840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
85841   void * jresult ;
85842   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85843   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85844
85845   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85846   {
85847     try {
85848       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85849     } catch (std::out_of_range& e) {
85850       {
85851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85852       };
85853     } catch (std::exception& e) {
85854       {
85855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85856       };
85857     } catch (Dali::DaliException e) {
85858       {
85859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85860       };
85861     } catch (...) {
85862       {
85863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85864       };
85865     }
85866   }
85867
85868   jresult = (void *)result;
85869   return jresult;
85870 }
85871
85872
85873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85874   void * jresult ;
85875   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85876   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85877
85878   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85879   {
85880     try {
85881       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85882     } catch (std::out_of_range& e) {
85883       {
85884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85885       };
85886     } catch (std::exception& e) {
85887       {
85888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85889       };
85890     } catch (Dali::DaliException e) {
85891       {
85892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85893       };
85894     } catch (...) {
85895       {
85896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85897       };
85898     }
85899   }
85900
85901   jresult = (void *)result;
85902   return jresult;
85903 }
85904
85905
85906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85907   void * jresult ;
85908   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85909   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85910
85911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85912   {
85913     try {
85914       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85915     } catch (std::out_of_range& e) {
85916       {
85917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85918       };
85919     } catch (std::exception& e) {
85920       {
85921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85922       };
85923     } catch (Dali::DaliException e) {
85924       {
85925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85926       };
85927     } catch (...) {
85928       {
85929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85930       };
85931     }
85932   }
85933
85934   jresult = (void *)result;
85935   return jresult;
85936 }
85937
85938
85939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85940   void * jresult ;
85941   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85942   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85943
85944   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85945   {
85946     try {
85947       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85948     } catch (std::out_of_range& e) {
85949       {
85950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85951       };
85952     } catch (std::exception& e) {
85953       {
85954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85955       };
85956     } catch (Dali::DaliException e) {
85957       {
85958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85959       };
85960     } catch (...) {
85961       {
85962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85963       };
85964     }
85965   }
85966
85967   jresult = (void *)result;
85968   return jresult;
85969 }
85970
85971
85972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85973   void * jresult ;
85974   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85975   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85976
85977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85978   {
85979     try {
85980       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85981     } catch (std::out_of_range& e) {
85982       {
85983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85984       };
85985     } catch (std::exception& e) {
85986       {
85987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85988       };
85989     } catch (Dali::DaliException e) {
85990       {
85991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85992       };
85993     } catch (...) {
85994       {
85995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85996       };
85997     }
85998   }
85999
86000   jresult = (void *)result;
86001   return jresult;
86002 }
86003
86004
86005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
86006   void * jresult ;
86007   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
86008   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
86009
86010   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
86011   {
86012     try {
86013       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
86014     } catch (std::out_of_range& e) {
86015       {
86016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86017       };
86018     } catch (std::exception& e) {
86019       {
86020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86021       };
86022     } catch (Dali::DaliException e) {
86023       {
86024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86025       };
86026     } catch (...) {
86027       {
86028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86029       };
86030     }
86031   }
86032
86033   jresult = (void *)result;
86034   return jresult;
86035 }
86036
86037
86038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86039   void * jresult ;
86040   Dali::Toolkit::StyleManager *result = 0 ;
86041
86042   {
86043     try {
86044       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86045     } catch (std::out_of_range& e) {
86046       {
86047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86048       };
86049     } catch (std::exception& e) {
86050       {
86051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86052       };
86053     } catch (Dali::DaliException e) {
86054       {
86055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86056       };
86057     } catch (...) {
86058       {
86059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86060       };
86061     }
86062   }
86063
86064   jresult = (void *)result;
86065   return jresult;
86066 }
86067
86068
86069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86070   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86071
86072   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86073   {
86074     try {
86075       delete arg1;
86076     } catch (std::out_of_range& e) {
86077       {
86078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86079       };
86080     } catch (std::exception& e) {
86081       {
86082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86083       };
86084     } catch (Dali::DaliException e) {
86085       {
86086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86087       };
86088     } catch (...) {
86089       {
86090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86091       };
86092     }
86093   }
86094
86095 }
86096
86097
86098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86099   void * jresult ;
86100   Dali::Toolkit::StyleManager result;
86101
86102   {
86103     try {
86104       result = Dali::Toolkit::StyleManager::Get();
86105     } catch (std::out_of_range& e) {
86106       {
86107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86108       };
86109     } catch (std::exception& e) {
86110       {
86111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86112       };
86113     } catch (Dali::DaliException e) {
86114       {
86115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86116       };
86117     } catch (...) {
86118       {
86119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86120       };
86121     }
86122   }
86123
86124   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86125   return jresult;
86126 }
86127
86128
86129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86130   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86131   std::string *arg2 = 0 ;
86132
86133   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86134   if (!jarg2) {
86135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86136     return ;
86137   }
86138   std::string arg2_str(jarg2);
86139   arg2 = &arg2_str;
86140   {
86141     try {
86142       (arg1)->ApplyTheme((std::string const &)*arg2);
86143     } catch (std::out_of_range& e) {
86144       {
86145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86146       };
86147     } catch (std::exception& e) {
86148       {
86149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86150       };
86151     } catch (Dali::DaliException e) {
86152       {
86153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86154       };
86155     } catch (...) {
86156       {
86157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86158       };
86159     }
86160   }
86161
86162
86163   //argout typemap for const std::string&
86164
86165 }
86166
86167
86168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86169   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86170
86171   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86172   {
86173     try {
86174       (arg1)->ApplyDefaultTheme();
86175     } catch (std::out_of_range& e) {
86176       {
86177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86178       };
86179     } catch (std::exception& e) {
86180       {
86181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86182       };
86183     } catch (Dali::DaliException e) {
86184       {
86185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86186       };
86187     } catch (...) {
86188       {
86189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86190       };
86191     }
86192   }
86193
86194 }
86195
86196
86197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86198   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86199   std::string *arg2 = 0 ;
86200   Dali::Property::Value *arg3 = 0 ;
86201
86202   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86203   if (!jarg2) {
86204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86205     return ;
86206   }
86207   std::string arg2_str(jarg2);
86208   arg2 = &arg2_str;
86209   arg3 = (Dali::Property::Value *)jarg3;
86210   if (!arg3) {
86211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86212     return ;
86213   }
86214   {
86215     try {
86216       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86217     } catch (std::out_of_range& e) {
86218       {
86219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86220       };
86221     } catch (std::exception& e) {
86222       {
86223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86224       };
86225     } catch (Dali::DaliException e) {
86226       {
86227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86228       };
86229     } catch (...) {
86230       {
86231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86232       };
86233     }
86234   }
86235
86236
86237   //argout typemap for const std::string&
86238
86239 }
86240
86241
86242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86243   unsigned int jresult ;
86244   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86245   std::string *arg2 = 0 ;
86246   Dali::Property::Value *arg3 = 0 ;
86247   bool result;
86248
86249   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86250   if (!jarg2) {
86251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86252     return 0;
86253   }
86254   std::string arg2_str(jarg2);
86255   arg2 = &arg2_str;
86256   arg3 = (Dali::Property::Value *)jarg3;
86257   if (!arg3) {
86258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86259     return 0;
86260   }
86261   {
86262     try {
86263       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86264     } catch (std::out_of_range& e) {
86265       {
86266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86267       };
86268     } catch (std::exception& e) {
86269       {
86270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86271       };
86272     } catch (Dali::DaliException e) {
86273       {
86274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86275       };
86276     } catch (...) {
86277       {
86278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86279       };
86280     }
86281   }
86282
86283   jresult = result;
86284
86285   //argout typemap for const std::string&
86286
86287   return jresult;
86288 }
86289
86290
86291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86292   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86293   Dali::Toolkit::Control arg2 ;
86294   std::string *arg3 = 0 ;
86295   std::string *arg4 = 0 ;
86296   Dali::Toolkit::Control *argp2 ;
86297
86298   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86299   argp2 = (Dali::Toolkit::Control *)jarg2;
86300   if (!argp2) {
86301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86302     return ;
86303   }
86304   arg2 = *argp2;
86305   if (!jarg3) {
86306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86307     return ;
86308   }
86309   std::string arg3_str(jarg3);
86310   arg3 = &arg3_str;
86311   if (!jarg4) {
86312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86313     return ;
86314   }
86315   std::string arg4_str(jarg4);
86316   arg4 = &arg4_str;
86317   {
86318     try {
86319       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86320     } catch (std::out_of_range& e) {
86321       {
86322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86323       };
86324     } catch (std::exception& e) {
86325       {
86326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86327       };
86328     } catch (Dali::DaliException e) {
86329       {
86330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86331       };
86332     } catch (...) {
86333       {
86334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86335       };
86336     }
86337   }
86338
86339
86340   //argout typemap for const std::string&
86341
86342
86343   //argout typemap for const std::string&
86344
86345 }
86346
86347
86348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86349   void * jresult ;
86350   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86351   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86352
86353   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86354   {
86355     try {
86356       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86357     } catch (std::out_of_range& e) {
86358       {
86359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86360       };
86361     } catch (std::exception& e) {
86362       {
86363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86364       };
86365     } catch (Dali::DaliException e) {
86366       {
86367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86368       };
86369     } catch (...) {
86370       {
86371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86372       };
86373     }
86374   }
86375
86376   jresult = (void *)result;
86377   return jresult;
86378 }
86379
86380
86381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86382   int jresult ;
86383   int result;
86384
86385   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86386   jresult = (int)result;
86387   return jresult;
86388 }
86389
86390
86391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86392   int jresult ;
86393   int result;
86394
86395   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86396   jresult = (int)result;
86397   return jresult;
86398 }
86399
86400
86401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86402   int jresult ;
86403   int result;
86404
86405   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86406   jresult = (int)result;
86407   return jresult;
86408 }
86409
86410
86411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86412   int jresult ;
86413   int result;
86414
86415   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86416   jresult = (int)result;
86417   return jresult;
86418 }
86419
86420
86421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86422   int jresult ;
86423   int result;
86424
86425   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86426   jresult = (int)result;
86427   return jresult;
86428 }
86429
86430
86431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86432   int jresult ;
86433   int result;
86434
86435   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86436   jresult = (int)result;
86437   return jresult;
86438 }
86439
86440
86441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86442   int jresult ;
86443   int result;
86444
86445   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86446   jresult = (int)result;
86447   return jresult;
86448 }
86449
86450
86451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86452   int jresult ;
86453   int result;
86454
86455   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86456   jresult = (int)result;
86457   return jresult;
86458 }
86459
86460
86461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86462   int jresult ;
86463   int result;
86464
86465   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86466   jresult = (int)result;
86467   return jresult;
86468 }
86469
86470
86471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86472   int jresult ;
86473   int result;
86474
86475   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86476   jresult = (int)result;
86477   return jresult;
86478 }
86479
86480
86481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86482   int jresult ;
86483   int result;
86484
86485   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86486   jresult = (int)result;
86487   return jresult;
86488 }
86489
86490
86491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86492   int jresult ;
86493   int result;
86494
86495   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86496   jresult = (int)result;
86497   return jresult;
86498 }
86499
86500
86501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86502   int jresult ;
86503   int result;
86504
86505   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86506   jresult = (int)result;
86507   return jresult;
86508 }
86509
86510
86511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86512   int jresult ;
86513   int result;
86514
86515   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86516   jresult = (int)result;
86517   return jresult;
86518 }
86519
86520
86521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86522   int jresult ;
86523   int result;
86524
86525   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86526   jresult = (int)result;
86527   return jresult;
86528 }
86529
86530
86531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86532   void * jresult ;
86533   Dali::Toolkit::Slider::Property *result = 0 ;
86534
86535   {
86536     try {
86537       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86538     } catch (std::out_of_range& e) {
86539       {
86540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86541       };
86542     } catch (std::exception& e) {
86543       {
86544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86545       };
86546     } catch (Dali::DaliException e) {
86547       {
86548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86549       };
86550     } catch (...) {
86551       {
86552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86553       };
86554     }
86555   }
86556
86557   jresult = (void *)result;
86558   return jresult;
86559 }
86560
86561
86562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86563   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86564
86565   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86566   {
86567     try {
86568       delete arg1;
86569     } catch (std::out_of_range& e) {
86570       {
86571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86572       };
86573     } catch (std::exception& e) {
86574       {
86575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86576       };
86577     } catch (Dali::DaliException e) {
86578       {
86579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86580       };
86581     } catch (...) {
86582       {
86583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86584       };
86585     }
86586   }
86587
86588 }
86589
86590
86591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86592   void * jresult ;
86593   Dali::Toolkit::Slider result;
86594
86595   {
86596     try {
86597       result = Dali::Toolkit::Slider::New();
86598     } catch (std::out_of_range& e) {
86599       {
86600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86601       };
86602     } catch (std::exception& e) {
86603       {
86604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86605       };
86606     } catch (Dali::DaliException e) {
86607       {
86608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86609       };
86610     } catch (...) {
86611       {
86612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86613       };
86614     }
86615   }
86616
86617   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86618   return jresult;
86619 }
86620
86621
86622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86623   void * jresult ;
86624   Dali::Toolkit::Slider *result = 0 ;
86625
86626   {
86627     try {
86628       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86629     } catch (std::out_of_range& e) {
86630       {
86631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86632       };
86633     } catch (std::exception& e) {
86634       {
86635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86636       };
86637     } catch (Dali::DaliException e) {
86638       {
86639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86640       };
86641     } catch (...) {
86642       {
86643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86644       };
86645     }
86646   }
86647
86648   jresult = (void *)result;
86649   return jresult;
86650 }
86651
86652
86653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86654   void * jresult ;
86655   Dali::Toolkit::Slider *arg1 = 0 ;
86656   Dali::Toolkit::Slider *result = 0 ;
86657
86658   arg1 = (Dali::Toolkit::Slider *)jarg1;
86659   if (!arg1) {
86660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86661     return 0;
86662   }
86663   {
86664     try {
86665       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86666     } catch (std::out_of_range& e) {
86667       {
86668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86669       };
86670     } catch (std::exception& e) {
86671       {
86672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86673       };
86674     } catch (Dali::DaliException e) {
86675       {
86676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86677       };
86678     } catch (...) {
86679       {
86680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86681       };
86682     }
86683   }
86684
86685   jresult = (void *)result;
86686   return jresult;
86687 }
86688
86689
86690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86691   void * jresult ;
86692   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86693   Dali::Toolkit::Slider *arg2 = 0 ;
86694   Dali::Toolkit::Slider *result = 0 ;
86695
86696   arg1 = (Dali::Toolkit::Slider *)jarg1;
86697   arg2 = (Dali::Toolkit::Slider *)jarg2;
86698   if (!arg2) {
86699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86700     return 0;
86701   }
86702   {
86703     try {
86704       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
86705     } catch (std::out_of_range& e) {
86706       {
86707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86708       };
86709     } catch (std::exception& e) {
86710       {
86711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86712       };
86713     } catch (Dali::DaliException e) {
86714       {
86715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86716       };
86717     } catch (...) {
86718       {
86719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86720       };
86721     }
86722   }
86723
86724   jresult = (void *)result;
86725   return jresult;
86726 }
86727
86728
86729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
86730   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86731
86732   arg1 = (Dali::Toolkit::Slider *)jarg1;
86733   {
86734     try {
86735       delete arg1;
86736     } catch (std::out_of_range& e) {
86737       {
86738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86739       };
86740     } catch (std::exception& e) {
86741       {
86742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86743       };
86744     } catch (Dali::DaliException e) {
86745       {
86746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86747       };
86748     } catch (...) {
86749       {
86750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86751       };
86752     }
86753   }
86754
86755 }
86756
86757
86758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
86759   void * jresult ;
86760   Dali::BaseHandle arg1 ;
86761   Dali::BaseHandle *argp1 ;
86762   Dali::Toolkit::Slider result;
86763
86764   argp1 = (Dali::BaseHandle *)jarg1;
86765   if (!argp1) {
86766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86767     return 0;
86768   }
86769   arg1 = *argp1;
86770   {
86771     try {
86772       result = Dali::Toolkit::Slider::DownCast(arg1);
86773     } catch (std::out_of_range& e) {
86774       {
86775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86776       };
86777     } catch (std::exception& e) {
86778       {
86779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86780       };
86781     } catch (Dali::DaliException e) {
86782       {
86783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86784       };
86785     } catch (...) {
86786       {
86787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86788       };
86789     }
86790   }
86791
86792   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86793   return jresult;
86794 }
86795
86796
86797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
86798   void * jresult ;
86799   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86800   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86801
86802   arg1 = (Dali::Toolkit::Slider *)jarg1;
86803   {
86804     try {
86805       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
86806     } catch (std::out_of_range& e) {
86807       {
86808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86809       };
86810     } catch (std::exception& e) {
86811       {
86812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86813       };
86814     } catch (Dali::DaliException e) {
86815       {
86816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86817       };
86818     } catch (...) {
86819       {
86820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86821       };
86822     }
86823   }
86824
86825   jresult = (void *)result;
86826   return jresult;
86827 }
86828
86829
86830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
86831   void * jresult ;
86832   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86833   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86834
86835   arg1 = (Dali::Toolkit::Slider *)jarg1;
86836   {
86837     try {
86838       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
86839     } catch (std::out_of_range& e) {
86840       {
86841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86842       };
86843     } catch (std::exception& e) {
86844       {
86845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86846       };
86847     } catch (Dali::DaliException e) {
86848       {
86849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86850       };
86851     } catch (...) {
86852       {
86853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86854       };
86855     }
86856   }
86857
86858   jresult = (void *)result;
86859   return jresult;
86860 }
86861
86862
86863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86864   void * jresult ;
86865   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86866   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86867
86868   arg1 = (Dali::Toolkit::Slider *)jarg1;
86869   {
86870     try {
86871       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86872     } catch (std::out_of_range& e) {
86873       {
86874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86875       };
86876     } catch (std::exception& e) {
86877       {
86878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86879       };
86880     } catch (Dali::DaliException e) {
86881       {
86882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86883       };
86884     } catch (...) {
86885       {
86886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86887       };
86888     }
86889   }
86890
86891   jresult = (void *)result;
86892   return jresult;
86893 }
86894
86895
86896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86897   int jresult ;
86898   int result;
86899
86900   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86901   jresult = (int)result;
86902   return jresult;
86903 }
86904
86905
86906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86907   int jresult ;
86908   int result;
86909
86910   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86911   jresult = (int)result;
86912   return jresult;
86913 }
86914
86915
86916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86917   int jresult ;
86918   int result;
86919
86920   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86921   jresult = (int)result;
86922   return jresult;
86923 }
86924
86925
86926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86927   int jresult ;
86928   int result;
86929
86930   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86931   jresult = (int)result;
86932   return jresult;
86933 }
86934
86935
86936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86937   int result;
86938
86939   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86940
86941   return result;
86942 }
86943
86944
86945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86946   void * jresult ;
86947   Dali::Toolkit::VideoView::Property *result = 0 ;
86948
86949   {
86950     try {
86951       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86952     } catch (std::out_of_range& e) {
86953       {
86954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86955       };
86956     } catch (std::exception& e) {
86957       {
86958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86959       };
86960     } catch (Dali::DaliException e) {
86961       {
86962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86963       };
86964     } catch (...) {
86965       {
86966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86967       };
86968     }
86969   }
86970
86971   jresult = (void *)result;
86972   return jresult;
86973 }
86974
86975
86976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86977   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86978
86979   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86980   {
86981     try {
86982       delete arg1;
86983     } catch (std::out_of_range& e) {
86984       {
86985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86986       };
86987     } catch (std::exception& e) {
86988       {
86989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86990       };
86991     } catch (Dali::DaliException e) {
86992       {
86993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86994       };
86995     } catch (...) {
86996       {
86997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86998       };
86999     }
87000   }
87001
87002 }
87003
87004
87005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
87006   void * jresult ;
87007   Dali::Toolkit::VideoView result;
87008
87009   {
87010     try {
87011       result = Dali::Toolkit::VideoView::New();
87012     } catch (std::out_of_range& e) {
87013       {
87014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87015       };
87016     } catch (std::exception& e) {
87017       {
87018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87019       };
87020     } catch (Dali::DaliException e) {
87021       {
87022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87023       };
87024     } catch (...) {
87025       {
87026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87027       };
87028     }
87029   }
87030
87031   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87032   return jresult;
87033 }
87034
87035
87036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
87037   void * jresult ;
87038   std::string *arg1 = 0 ;
87039   Dali::Toolkit::VideoView result;
87040
87041   if (!jarg1) {
87042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87043     return 0;
87044   }
87045   std::string arg1_str(jarg1);
87046   arg1 = &arg1_str;
87047   {
87048     try {
87049       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
87050     } catch (std::out_of_range& e) {
87051       {
87052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87053       };
87054     } catch (std::exception& e) {
87055       {
87056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87057       };
87058     } catch (Dali::DaliException e) {
87059       {
87060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87061       };
87062     } catch (...) {
87063       {
87064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87065       };
87066     }
87067   }
87068
87069   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87070
87071   //argout typemap for const std::string&
87072
87073   return jresult;
87074 }
87075
87076
87077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87078   void * jresult ;
87079   Dali::Toolkit::VideoView *result = 0 ;
87080
87081   {
87082     try {
87083       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87084     } catch (std::out_of_range& e) {
87085       {
87086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87087       };
87088     } catch (std::exception& e) {
87089       {
87090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87091       };
87092     } catch (Dali::DaliException e) {
87093       {
87094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87095       };
87096     } catch (...) {
87097       {
87098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87099       };
87100     }
87101   }
87102
87103   jresult = (void *)result;
87104   return jresult;
87105 }
87106
87107
87108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87109   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87110
87111   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87112   {
87113     try {
87114       delete arg1;
87115     } catch (std::out_of_range& e) {
87116       {
87117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87118       };
87119     } catch (std::exception& e) {
87120       {
87121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87122       };
87123     } catch (Dali::DaliException e) {
87124       {
87125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87126       };
87127     } catch (...) {
87128       {
87129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87130       };
87131     }
87132   }
87133
87134 }
87135
87136
87137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87138   void * jresult ;
87139   Dali::Toolkit::VideoView *arg1 = 0 ;
87140   Dali::Toolkit::VideoView *result = 0 ;
87141
87142   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87143   if (!arg1) {
87144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87145     return 0;
87146   }
87147   {
87148     try {
87149       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87150     } catch (std::out_of_range& e) {
87151       {
87152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87153       };
87154     } catch (std::exception& e) {
87155       {
87156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87157       };
87158     } catch (Dali::DaliException e) {
87159       {
87160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87161       };
87162     } catch (...) {
87163       {
87164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87165       };
87166     }
87167   }
87168
87169   jresult = (void *)result;
87170   return jresult;
87171 }
87172
87173
87174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87175   void * jresult ;
87176   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87177   Dali::Toolkit::VideoView *arg2 = 0 ;
87178   Dali::Toolkit::VideoView *result = 0 ;
87179
87180   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87181   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87182   if (!arg2) {
87183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87184     return 0;
87185   }
87186   {
87187     try {
87188       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87189     } catch (std::out_of_range& e) {
87190       {
87191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87192       };
87193     } catch (std::exception& e) {
87194       {
87195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87196       };
87197     } catch (Dali::DaliException e) {
87198       {
87199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87200       };
87201     } catch (...) {
87202       {
87203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87204       };
87205     }
87206   }
87207
87208   jresult = (void *)result;
87209   return jresult;
87210 }
87211
87212
87213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87214   void * jresult ;
87215   Dali::BaseHandle arg1 ;
87216   Dali::BaseHandle *argp1 ;
87217   Dali::Toolkit::VideoView result;
87218
87219   argp1 = (Dali::BaseHandle *)jarg1;
87220   if (!argp1) {
87221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87222     return 0;
87223   }
87224   arg1 = *argp1;
87225   {
87226     try {
87227       result = Dali::Toolkit::VideoView::DownCast(arg1);
87228     } catch (std::out_of_range& e) {
87229       {
87230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87231       };
87232     } catch (std::exception& e) {
87233       {
87234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87235       };
87236     } catch (Dali::DaliException e) {
87237       {
87238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87239       };
87240     } catch (...) {
87241       {
87242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87243       };
87244     }
87245   }
87246
87247   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87248   return jresult;
87249 }
87250
87251
87252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87253   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87254
87255   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87256   {
87257     try {
87258       (arg1)->Play();
87259     } catch (std::out_of_range& e) {
87260       {
87261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87262       };
87263     } catch (std::exception& e) {
87264       {
87265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87266       };
87267     } catch (Dali::DaliException e) {
87268       {
87269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87270       };
87271     } catch (...) {
87272       {
87273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87274       };
87275     }
87276   }
87277
87278 }
87279
87280
87281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87282   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87283
87284   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87285   {
87286     try {
87287       (arg1)->Pause();
87288     } catch (std::out_of_range& e) {
87289       {
87290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87291       };
87292     } catch (std::exception& e) {
87293       {
87294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87295       };
87296     } catch (Dali::DaliException e) {
87297       {
87298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87299       };
87300     } catch (...) {
87301       {
87302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87303       };
87304     }
87305   }
87306
87307 }
87308
87309
87310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87311   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87312
87313   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87314   {
87315     try {
87316       (arg1)->Stop();
87317     } catch (std::out_of_range& e) {
87318       {
87319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87320       };
87321     } catch (std::exception& e) {
87322       {
87323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87324       };
87325     } catch (Dali::DaliException e) {
87326       {
87327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87328       };
87329     } catch (...) {
87330       {
87331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87332       };
87333     }
87334   }
87335
87336 }
87337
87338
87339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87340   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87341   int arg2 ;
87342
87343   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87344   arg2 = (int)jarg2;
87345   {
87346     try {
87347       (arg1)->Forward(arg2);
87348     } catch (std::out_of_range& e) {
87349       {
87350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87351       };
87352     } catch (std::exception& e) {
87353       {
87354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87355       };
87356     } catch (Dali::DaliException e) {
87357       {
87358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87359       };
87360     } catch (...) {
87361       {
87362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87363       };
87364     }
87365   }
87366
87367 }
87368
87369
87370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87371   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87372   int arg2 ;
87373
87374   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87375   arg2 = (int)jarg2;
87376   {
87377     try {
87378       (arg1)->Backward(arg2);
87379     } catch (std::out_of_range& e) {
87380       {
87381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87382       };
87383     } catch (std::exception& e) {
87384       {
87385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87386       };
87387     } catch (Dali::DaliException e) {
87388       {
87389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87390       };
87391     } catch (...) {
87392       {
87393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87394       };
87395     }
87396   }
87397
87398 }
87399
87400
87401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87402   void * jresult ;
87403   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87404   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87405
87406   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87407   {
87408     try {
87409       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87410     } catch (std::out_of_range& e) {
87411       {
87412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87413       };
87414     } catch (std::exception& e) {
87415       {
87416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87417       };
87418     } catch (Dali::DaliException e) {
87419       {
87420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87421       };
87422     } catch (...) {
87423       {
87424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87425       };
87426     }
87427   }
87428
87429   jresult = (void *)result;
87430   return jresult;
87431 }
87432
87433
87434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87435   int jresult ;
87436   int result;
87437
87438   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87439   jresult = (int)result;
87440   return jresult;
87441 }
87442
87443
87444 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87445   int jresult ;
87446   int result;
87447
87448   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87449   jresult = (int)result;
87450   return jresult;
87451 }
87452
87453
87454 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87455   int jresult ;
87456   int result;
87457
87458   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87459   jresult = (int)result;
87460   return jresult;
87461 }
87462
87463
87464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87465   int jresult ;
87466   int result;
87467
87468   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87469   jresult = (int)result;
87470   return jresult;
87471 }
87472
87473
87474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87475   int jresult ;
87476   int result;
87477
87478   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87479   jresult = (int)result;
87480   return jresult;
87481 }
87482
87483
87484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87485   int jresult ;
87486   int result;
87487
87488   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87489   jresult = (int)result;
87490   return jresult;
87491 }
87492
87493
87494 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87495   int jresult ;
87496   int result;
87497
87498   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87499   jresult = (int)result;
87500   return jresult;
87501 }
87502
87503
87504 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87505   int jresult ;
87506   int result;
87507
87508   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87509   jresult = (int)result;
87510   return jresult;
87511 }
87512
87513
87514 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87515   int jresult ;
87516   int result;
87517
87518   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87519   jresult = (int)result;
87520   return jresult;
87521 }
87522
87523
87524 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87525   int jresult ;
87526   int result;
87527
87528   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87529   jresult = (int)result;
87530   return jresult;
87531 }
87532
87533
87534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87535   int jresult ;
87536   int result;
87537
87538   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87539   jresult = (int)result;
87540   return jresult;
87541 }
87542
87543
87544 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87545   int jresult ;
87546   int result;
87547
87548   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87549   jresult = (int)result;
87550   return jresult;
87551 }
87552
87553
87554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87555   int jresult ;
87556   int result;
87557
87558   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87559   jresult = (int)result;
87560   return jresult;
87561 }
87562
87563
87564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87565   int jresult ;
87566   int result;
87567
87568   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87569   jresult = (int)result;
87570   return jresult;
87571 }
87572
87573
87574 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87575   int jresult ;
87576   int result;
87577
87578   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87579   jresult = (int)result;
87580   return jresult;
87581 }
87582
87583
87584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87585   int jresult ;
87586   int result;
87587
87588   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87589   jresult = (int)result;
87590   return jresult;
87591 }
87592
87593
87594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87595   int jresult ;
87596   int result;
87597
87598   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87599   jresult = (int)result;
87600   return jresult;
87601 }
87602
87603
87604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87605   int jresult ;
87606   int result;
87607
87608   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87609   jresult = (int)result;
87610   return jresult;
87611 }
87612
87613
87614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87615   int jresult ;
87616   int result;
87617
87618   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87619   jresult = (int)result;
87620   return jresult;
87621 }
87622
87623
87624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87625   int jresult ;
87626   int result;
87627
87628   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87629   jresult = (int)result;
87630   return jresult;
87631 }
87632
87633
87634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87635   int jresult ;
87636   int result;
87637
87638   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87639   jresult = (int)result;
87640   return jresult;
87641 }
87642
87643
87644 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87645   void * jresult ;
87646   Dali::Toolkit::Popup::Property *result = 0 ;
87647
87648   {
87649     try {
87650       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87651     } catch (std::out_of_range& e) {
87652       {
87653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87654       };
87655     } catch (std::exception& e) {
87656       {
87657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87658       };
87659     } catch (Dali::DaliException e) {
87660       {
87661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87662       };
87663     } catch (...) {
87664       {
87665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87666       };
87667     }
87668   }
87669
87670   jresult = (void *)result;
87671   return jresult;
87672 }
87673
87674
87675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87676   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87677
87678   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87679   {
87680     try {
87681       delete arg1;
87682     } catch (std::out_of_range& e) {
87683       {
87684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87685       };
87686     } catch (std::exception& e) {
87687       {
87688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87689       };
87690     } catch (Dali::DaliException e) {
87691       {
87692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87693       };
87694     } catch (...) {
87695       {
87696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87697       };
87698     }
87699   }
87700
87701 }
87702
87703
87704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
87705   void * jresult ;
87706   Dali::Toolkit::Popup *result = 0 ;
87707
87708   {
87709     try {
87710       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
87711     } catch (std::out_of_range& e) {
87712       {
87713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87714       };
87715     } catch (std::exception& e) {
87716       {
87717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87718       };
87719     } catch (Dali::DaliException e) {
87720       {
87721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87722       };
87723     } catch (...) {
87724       {
87725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87726       };
87727     }
87728   }
87729
87730   jresult = (void *)result;
87731   return jresult;
87732 }
87733
87734
87735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87736   void * jresult ;
87737   Dali::Toolkit::Popup result;
87738
87739   {
87740     try {
87741       result = Dali::Toolkit::Popup::New();
87742     } catch (std::out_of_range& e) {
87743       {
87744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87745       };
87746     } catch (std::exception& e) {
87747       {
87748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87749       };
87750     } catch (Dali::DaliException e) {
87751       {
87752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87753       };
87754     } catch (...) {
87755       {
87756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87757       };
87758     }
87759   }
87760
87761   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87762   return jresult;
87763 }
87764
87765
87766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87767   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87768
87769   arg1 = (Dali::Toolkit::Popup *)jarg1;
87770   {
87771     try {
87772       delete arg1;
87773     } catch (std::out_of_range& e) {
87774       {
87775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87776       };
87777     } catch (std::exception& e) {
87778       {
87779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87780       };
87781     } catch (Dali::DaliException e) {
87782       {
87783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87784       };
87785     } catch (...) {
87786       {
87787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87788       };
87789     }
87790   }
87791
87792 }
87793
87794
87795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87796   void * jresult ;
87797   Dali::Toolkit::Popup *arg1 = 0 ;
87798   Dali::Toolkit::Popup *result = 0 ;
87799
87800   arg1 = (Dali::Toolkit::Popup *)jarg1;
87801   if (!arg1) {
87802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87803     return 0;
87804   }
87805   {
87806     try {
87807       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87808     } catch (std::out_of_range& e) {
87809       {
87810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87811       };
87812     } catch (std::exception& e) {
87813       {
87814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87815       };
87816     } catch (Dali::DaliException e) {
87817       {
87818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87819       };
87820     } catch (...) {
87821       {
87822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87823       };
87824     }
87825   }
87826
87827   jresult = (void *)result;
87828   return jresult;
87829 }
87830
87831
87832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87833   void * jresult ;
87834   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87835   Dali::Toolkit::Popup *arg2 = 0 ;
87836   Dali::Toolkit::Popup *result = 0 ;
87837
87838   arg1 = (Dali::Toolkit::Popup *)jarg1;
87839   arg2 = (Dali::Toolkit::Popup *)jarg2;
87840   if (!arg2) {
87841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87842     return 0;
87843   }
87844   {
87845     try {
87846       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87847     } catch (std::out_of_range& e) {
87848       {
87849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87850       };
87851     } catch (std::exception& e) {
87852       {
87853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87854       };
87855     } catch (Dali::DaliException e) {
87856       {
87857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87858       };
87859     } catch (...) {
87860       {
87861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87862       };
87863     }
87864   }
87865
87866   jresult = (void *)result;
87867   return jresult;
87868 }
87869
87870
87871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87872   void * jresult ;
87873   Dali::BaseHandle arg1 ;
87874   Dali::BaseHandle *argp1 ;
87875   Dali::Toolkit::Popup result;
87876
87877   argp1 = (Dali::BaseHandle *)jarg1;
87878   if (!argp1) {
87879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87880     return 0;
87881   }
87882   arg1 = *argp1;
87883   {
87884     try {
87885       result = Dali::Toolkit::Popup::DownCast(arg1);
87886     } catch (std::out_of_range& e) {
87887       {
87888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87889       };
87890     } catch (std::exception& e) {
87891       {
87892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87893       };
87894     } catch (Dali::DaliException e) {
87895       {
87896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87897       };
87898     } catch (...) {
87899       {
87900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87901       };
87902     }
87903   }
87904
87905   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87906   return jresult;
87907 }
87908
87909
87910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87911   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87912   Dali::Actor arg2 ;
87913   Dali::Actor *argp2 ;
87914
87915   arg1 = (Dali::Toolkit::Popup *)jarg1;
87916   argp2 = (Dali::Actor *)jarg2;
87917   if (!argp2) {
87918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87919     return ;
87920   }
87921   arg2 = *argp2;
87922   {
87923     try {
87924       (arg1)->SetTitle(arg2);
87925     } catch (std::out_of_range& e) {
87926       {
87927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87928       };
87929     } catch (std::exception& e) {
87930       {
87931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87932       };
87933     } catch (Dali::DaliException e) {
87934       {
87935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87936       };
87937     } catch (...) {
87938       {
87939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87940       };
87941     }
87942   }
87943
87944 }
87945
87946
87947 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87948   void * jresult ;
87949   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87950   Dali::Actor result;
87951
87952   arg1 = (Dali::Toolkit::Popup *)jarg1;
87953   {
87954     try {
87955       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87956     } catch (std::out_of_range& e) {
87957       {
87958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87959       };
87960     } catch (std::exception& e) {
87961       {
87962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87963       };
87964     } catch (Dali::DaliException e) {
87965       {
87966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87967       };
87968     } catch (...) {
87969       {
87970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87971       };
87972     }
87973   }
87974
87975   jresult = new Dali::Actor((const Dali::Actor &)result);
87976   return jresult;
87977 }
87978
87979
87980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87981   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87982   Dali::Actor arg2 ;
87983   Dali::Actor *argp2 ;
87984
87985   arg1 = (Dali::Toolkit::Popup *)jarg1;
87986   argp2 = (Dali::Actor *)jarg2;
87987   if (!argp2) {
87988     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87989     return ;
87990   }
87991   arg2 = *argp2;
87992   {
87993     try {
87994       (arg1)->SetContent(arg2);
87995     } catch (std::out_of_range& e) {
87996       {
87997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87998       };
87999     } catch (std::exception& e) {
88000       {
88001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88002       };
88003     } catch (Dali::DaliException e) {
88004       {
88005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88006       };
88007     } catch (...) {
88008       {
88009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88010       };
88011     }
88012   }
88013
88014 }
88015
88016
88017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
88018   void * jresult ;
88019   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88020   Dali::Actor result;
88021
88022   arg1 = (Dali::Toolkit::Popup *)jarg1;
88023   {
88024     try {
88025       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
88026     } catch (std::out_of_range& e) {
88027       {
88028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88029       };
88030     } catch (std::exception& e) {
88031       {
88032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88033       };
88034     } catch (Dali::DaliException e) {
88035       {
88036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88037       };
88038     } catch (...) {
88039       {
88040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88041       };
88042     }
88043   }
88044
88045   jresult = new Dali::Actor((const Dali::Actor &)result);
88046   return jresult;
88047 }
88048
88049
88050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88051   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88052   Dali::Actor arg2 ;
88053   Dali::Actor *argp2 ;
88054
88055   arg1 = (Dali::Toolkit::Popup *)jarg1;
88056   argp2 = (Dali::Actor *)jarg2;
88057   if (!argp2) {
88058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88059     return ;
88060   }
88061   arg2 = *argp2;
88062   {
88063     try {
88064       (arg1)->SetFooter(arg2);
88065     } catch (std::out_of_range& e) {
88066       {
88067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88068       };
88069     } catch (std::exception& e) {
88070       {
88071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88072       };
88073     } catch (Dali::DaliException e) {
88074       {
88075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88076       };
88077     } catch (...) {
88078       {
88079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88080       };
88081     }
88082   }
88083
88084 }
88085
88086
88087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88088   void * jresult ;
88089   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88090   Dali::Actor result;
88091
88092   arg1 = (Dali::Toolkit::Popup *)jarg1;
88093   {
88094     try {
88095       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88096     } catch (std::out_of_range& e) {
88097       {
88098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88099       };
88100     } catch (std::exception& e) {
88101       {
88102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88103       };
88104     } catch (Dali::DaliException e) {
88105       {
88106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88107       };
88108     } catch (...) {
88109       {
88110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88111       };
88112     }
88113   }
88114
88115   jresult = new Dali::Actor((const Dali::Actor &)result);
88116   return jresult;
88117 }
88118
88119
88120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88121   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88122   Dali::Toolkit::Popup::DisplayState arg2 ;
88123
88124   arg1 = (Dali::Toolkit::Popup *)jarg1;
88125   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88126   {
88127     try {
88128       (arg1)->SetDisplayState(arg2);
88129     } catch (std::out_of_range& e) {
88130       {
88131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88132       };
88133     } catch (std::exception& e) {
88134       {
88135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88136       };
88137     } catch (Dali::DaliException e) {
88138       {
88139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88140       };
88141     } catch (...) {
88142       {
88143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88144       };
88145     }
88146   }
88147
88148 }
88149
88150
88151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88152   int jresult ;
88153   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88154   Dali::Toolkit::Popup::DisplayState result;
88155
88156   arg1 = (Dali::Toolkit::Popup *)jarg1;
88157   {
88158     try {
88159       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88160     } catch (std::out_of_range& e) {
88161       {
88162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88163       };
88164     } catch (std::exception& e) {
88165       {
88166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88167       };
88168     } catch (Dali::DaliException e) {
88169       {
88170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88171       };
88172     } catch (...) {
88173       {
88174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88175       };
88176     }
88177   }
88178
88179   jresult = (int)result;
88180   return jresult;
88181 }
88182
88183
88184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88185   void * jresult ;
88186   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88187   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88188
88189   arg1 = (Dali::Toolkit::Popup *)jarg1;
88190   {
88191     try {
88192       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88193     } catch (std::out_of_range& e) {
88194       {
88195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88196       };
88197     } catch (std::exception& e) {
88198       {
88199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88200       };
88201     } catch (Dali::DaliException e) {
88202       {
88203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88204       };
88205     } catch (...) {
88206       {
88207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88208       };
88209     }
88210   }
88211
88212   jresult = (void *)result;
88213   return jresult;
88214 }
88215
88216
88217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88218   void * jresult ;
88219   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88220   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88221
88222   arg1 = (Dali::Toolkit::Popup *)jarg1;
88223   {
88224     try {
88225       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88226     } catch (std::out_of_range& e) {
88227       {
88228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88229       };
88230     } catch (std::exception& e) {
88231       {
88232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88233       };
88234     } catch (Dali::DaliException e) {
88235       {
88236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88237       };
88238     } catch (...) {
88239       {
88240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88241       };
88242     }
88243   }
88244
88245   jresult = (void *)result;
88246   return jresult;
88247 }
88248
88249
88250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88251   void * jresult ;
88252   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88253   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88254
88255   arg1 = (Dali::Toolkit::Popup *)jarg1;
88256   {
88257     try {
88258       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88259     } catch (std::out_of_range& e) {
88260       {
88261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88262       };
88263     } catch (std::exception& e) {
88264       {
88265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88266       };
88267     } catch (Dali::DaliException e) {
88268       {
88269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88270       };
88271     } catch (...) {
88272       {
88273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88274       };
88275     }
88276   }
88277
88278   jresult = (void *)result;
88279   return jresult;
88280 }
88281
88282
88283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88284   void * jresult ;
88285   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88286   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88287
88288   arg1 = (Dali::Toolkit::Popup *)jarg1;
88289   {
88290     try {
88291       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88292     } catch (std::out_of_range& e) {
88293       {
88294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88295       };
88296     } catch (std::exception& e) {
88297       {
88298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88299       };
88300     } catch (Dali::DaliException e) {
88301       {
88302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88303       };
88304     } catch (...) {
88305       {
88306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88307       };
88308     }
88309   }
88310
88311   jresult = (void *)result;
88312   return jresult;
88313 }
88314
88315
88316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88317   void * jresult ;
88318   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88319   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88320
88321   arg1 = (Dali::Toolkit::Popup *)jarg1;
88322   {
88323     try {
88324       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88325     } catch (std::out_of_range& e) {
88326       {
88327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88328       };
88329     } catch (std::exception& e) {
88330       {
88331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88332       };
88333     } catch (Dali::DaliException e) {
88334       {
88335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88336       };
88337     } catch (...) {
88338       {
88339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88340       };
88341     }
88342   }
88343
88344   jresult = (void *)result;
88345   return jresult;
88346 }
88347
88348
88349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88350   int jresult ;
88351   int result;
88352
88353   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88354   jresult = (int)result;
88355   return jresult;
88356 }
88357
88358
88359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88360   int jresult ;
88361   int result;
88362
88363   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88364   jresult = (int)result;
88365   return jresult;
88366 }
88367
88368
88369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88370   int jresult ;
88371   int result;
88372
88373   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88374   jresult = (int)result;
88375   return jresult;
88376 }
88377
88378
88379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88380   int jresult ;
88381   int result;
88382
88383   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88384   jresult = (int)result;
88385   return jresult;
88386 }
88387
88388
88389 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88390   int jresult ;
88391   int result;
88392
88393   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88394   jresult = (int)result;
88395   return jresult;
88396 }
88397
88398
88399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88400   int jresult ;
88401   int result;
88402
88403   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88404   jresult = (int)result;
88405   return jresult;
88406 }
88407
88408
88409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88410   int jresult ;
88411   int result;
88412
88413   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88414   jresult = (int)result;
88415   return jresult;
88416 }
88417
88418
88419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88420   int jresult ;
88421   int result;
88422
88423   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88424   jresult = (int)result;
88425   return jresult;
88426 }
88427
88428
88429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88430   int jresult ;
88431   int result;
88432
88433   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88434   jresult = (int)result;
88435   return jresult;
88436 }
88437
88438
88439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88440   void * jresult ;
88441   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88442
88443   {
88444     try {
88445       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88446     } catch (std::out_of_range& e) {
88447       {
88448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88449       };
88450     } catch (std::exception& e) {
88451       {
88452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88453       };
88454     } catch (Dali::DaliException e) {
88455       {
88456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88457       };
88458     } catch (...) {
88459       {
88460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88461       };
88462     }
88463   }
88464
88465   jresult = (void *)result;
88466   return jresult;
88467 }
88468
88469
88470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88471   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88472
88473   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88474   {
88475     try {
88476       delete arg1;
88477     } catch (std::out_of_range& e) {
88478       {
88479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88480       };
88481     } catch (std::exception& e) {
88482       {
88483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88484       };
88485     } catch (Dali::DaliException e) {
88486       {
88487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88488       };
88489     } catch (...) {
88490       {
88491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88492       };
88493     }
88494   }
88495
88496 }
88497
88498
88499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88500   void * jresult ;
88501   Dali::Toolkit::ProgressBar result;
88502
88503   {
88504     try {
88505       result = Dali::Toolkit::ProgressBar::New();
88506     } catch (std::out_of_range& e) {
88507       {
88508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88509       };
88510     } catch (std::exception& e) {
88511       {
88512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88513       };
88514     } catch (Dali::DaliException e) {
88515       {
88516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88517       };
88518     } catch (...) {
88519       {
88520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88521       };
88522     }
88523   }
88524
88525   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88526   return jresult;
88527 }
88528
88529
88530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88531   void * jresult ;
88532   Dali::Toolkit::ProgressBar *result = 0 ;
88533
88534   {
88535     try {
88536       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88537     } catch (std::out_of_range& e) {
88538       {
88539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88540       };
88541     } catch (std::exception& e) {
88542       {
88543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88544       };
88545     } catch (Dali::DaliException e) {
88546       {
88547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88548       };
88549     } catch (...) {
88550       {
88551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88552       };
88553     }
88554   }
88555
88556   jresult = (void *)result;
88557   return jresult;
88558 }
88559
88560
88561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88562   void * jresult ;
88563   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88564   Dali::Toolkit::ProgressBar *result = 0 ;
88565
88566   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88567   if (!arg1) {
88568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88569     return 0;
88570   }
88571   {
88572     try {
88573       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88574     } catch (std::out_of_range& e) {
88575       {
88576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88577       };
88578     } catch (std::exception& e) {
88579       {
88580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88581       };
88582     } catch (Dali::DaliException e) {
88583       {
88584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88585       };
88586     } catch (...) {
88587       {
88588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88589       };
88590     }
88591   }
88592
88593   jresult = (void *)result;
88594   return jresult;
88595 }
88596
88597
88598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88599   void * jresult ;
88600   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88601   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88602   Dali::Toolkit::ProgressBar *result = 0 ;
88603
88604   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88605   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88606   if (!arg2) {
88607     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88608     return 0;
88609   }
88610   {
88611     try {
88612       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88613     } catch (std::out_of_range& e) {
88614       {
88615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88616       };
88617     } catch (std::exception& e) {
88618       {
88619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88620       };
88621     } catch (Dali::DaliException e) {
88622       {
88623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88624       };
88625     } catch (...) {
88626       {
88627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88628       };
88629     }
88630   }
88631
88632   jresult = (void *)result;
88633   return jresult;
88634 }
88635
88636
88637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88638   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88639
88640   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88641   {
88642     try {
88643       delete arg1;
88644     } catch (std::out_of_range& e) {
88645       {
88646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88647       };
88648     } catch (std::exception& e) {
88649       {
88650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88651       };
88652     } catch (Dali::DaliException e) {
88653       {
88654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88655       };
88656     } catch (...) {
88657       {
88658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88659       };
88660     }
88661   }
88662
88663 }
88664
88665
88666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88667   void * jresult ;
88668   Dali::BaseHandle arg1 ;
88669   Dali::BaseHandle *argp1 ;
88670   Dali::Toolkit::ProgressBar result;
88671
88672   argp1 = (Dali::BaseHandle *)jarg1;
88673   if (!argp1) {
88674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88675     return 0;
88676   }
88677   arg1 = *argp1;
88678   {
88679     try {
88680       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88681     } catch (std::out_of_range& e) {
88682       {
88683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88684       };
88685     } catch (std::exception& e) {
88686       {
88687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88688       };
88689     } catch (Dali::DaliException e) {
88690       {
88691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88692       };
88693     } catch (...) {
88694       {
88695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88696       };
88697     }
88698   }
88699
88700   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88701   return jresult;
88702 }
88703
88704
88705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
88706   void * jresult ;
88707   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88708   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
88709
88710   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88711   {
88712     try {
88713       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
88714     } catch (std::out_of_range& e) {
88715       {
88716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88717       };
88718     } catch (std::exception& e) {
88719       {
88720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88721       };
88722     } catch (Dali::DaliException e) {
88723       {
88724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88725       };
88726     } catch (...) {
88727       {
88728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88729       };
88730     }
88731   }
88732
88733   jresult = (void *)result;
88734   return jresult;
88735 }
88736
88737
88738 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88739   void * jresult ;
88740   Dali::Toolkit::GaussianBlurView *result = 0 ;
88741
88742   {
88743     try {
88744       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88745     } catch (std::out_of_range& e) {
88746       {
88747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88748       };
88749     } catch (std::exception& e) {
88750       {
88751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88752       };
88753     } catch (Dali::DaliException e) {
88754       {
88755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88756       };
88757     } catch (...) {
88758       {
88759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88760       };
88761     }
88762   }
88763
88764   jresult = (void *)result;
88765   return jresult;
88766 }
88767
88768
88769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88770   void * jresult ;
88771   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88772   Dali::Toolkit::GaussianBlurView *result = 0 ;
88773
88774   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88775   if (!arg1) {
88776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88777     return 0;
88778   }
88779   {
88780     try {
88781       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88782     } catch (std::out_of_range& e) {
88783       {
88784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88785       };
88786     } catch (std::exception& e) {
88787       {
88788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88789       };
88790     } catch (Dali::DaliException e) {
88791       {
88792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88793       };
88794     } catch (...) {
88795       {
88796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88797       };
88798     }
88799   }
88800
88801   jresult = (void *)result;
88802   return jresult;
88803 }
88804
88805
88806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88807   void * jresult ;
88808   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88809   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88810   Dali::Toolkit::GaussianBlurView *result = 0 ;
88811
88812   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88813   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88814   if (!arg2) {
88815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88816     return 0;
88817   }
88818   {
88819     try {
88820       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88821     } catch (std::out_of_range& e) {
88822       {
88823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88824       };
88825     } catch (std::exception& e) {
88826       {
88827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88828       };
88829     } catch (Dali::DaliException e) {
88830       {
88831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88832       };
88833     } catch (...) {
88834       {
88835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88836       };
88837     }
88838   }
88839
88840   jresult = (void *)result;
88841   return jresult;
88842 }
88843
88844
88845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88846   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88847
88848   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88849   {
88850     try {
88851       delete arg1;
88852     } catch (std::out_of_range& e) {
88853       {
88854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88855       };
88856     } catch (std::exception& e) {
88857       {
88858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88859       };
88860     } catch (Dali::DaliException e) {
88861       {
88862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88863       };
88864     } catch (...) {
88865       {
88866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88867       };
88868     }
88869   }
88870
88871 }
88872
88873
88874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88875   void * jresult ;
88876   Dali::BaseHandle arg1 ;
88877   Dali::BaseHandle *argp1 ;
88878   Dali::Toolkit::GaussianBlurView result;
88879
88880   argp1 = (Dali::BaseHandle *)jarg1;
88881   if (!argp1) {
88882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88883     return 0;
88884   }
88885   arg1 = *argp1;
88886   {
88887     try {
88888       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88889     } catch (std::out_of_range& e) {
88890       {
88891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88892       };
88893     } catch (std::exception& e) {
88894       {
88895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88896       };
88897     } catch (Dali::DaliException e) {
88898       {
88899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88900       };
88901     } catch (...) {
88902       {
88903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88904       };
88905     }
88906   }
88907
88908   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88909   return jresult;
88910 }
88911
88912
88913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88914   void * jresult ;
88915   Dali::Toolkit::GaussianBlurView result;
88916
88917   {
88918     try {
88919       result = Dali::Toolkit::GaussianBlurView::New();
88920     } catch (std::out_of_range& e) {
88921       {
88922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88923       };
88924     } catch (std::exception& e) {
88925       {
88926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88927       };
88928     } catch (Dali::DaliException e) {
88929       {
88930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88931       };
88932     } catch (...) {
88933       {
88934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88935       };
88936     }
88937   }
88938
88939   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88940   return jresult;
88941 }
88942
88943
88944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88945   void * jresult ;
88946   unsigned int arg1 ;
88947   float arg2 ;
88948   Dali::Pixel::Format arg3 ;
88949   float arg4 ;
88950   float arg5 ;
88951   bool arg6 ;
88952   Dali::Toolkit::GaussianBlurView result;
88953
88954   arg1 = (unsigned int)jarg1;
88955   arg2 = (float)jarg2;
88956   arg3 = (Dali::Pixel::Format)jarg3;
88957   arg4 = (float)jarg4;
88958   arg5 = (float)jarg5;
88959   arg6 = jarg6 ? true : false;
88960   {
88961     try {
88962       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88963     } catch (std::out_of_range& e) {
88964       {
88965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88966       };
88967     } catch (std::exception& e) {
88968       {
88969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88970       };
88971     } catch (Dali::DaliException e) {
88972       {
88973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88974       };
88975     } catch (...) {
88976       {
88977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88978       };
88979     }
88980   }
88981
88982   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88983   return jresult;
88984 }
88985
88986
88987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88988   void * jresult ;
88989   unsigned int arg1 ;
88990   float arg2 ;
88991   Dali::Pixel::Format arg3 ;
88992   float arg4 ;
88993   float arg5 ;
88994   Dali::Toolkit::GaussianBlurView result;
88995
88996   arg1 = (unsigned int)jarg1;
88997   arg2 = (float)jarg2;
88998   arg3 = (Dali::Pixel::Format)jarg3;
88999   arg4 = (float)jarg4;
89000   arg5 = (float)jarg5;
89001   {
89002     try {
89003       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
89004     } catch (std::out_of_range& e) {
89005       {
89006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89007       };
89008     } catch (std::exception& e) {
89009       {
89010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89011       };
89012     } catch (Dali::DaliException e) {
89013       {
89014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89015       };
89016     } catch (...) {
89017       {
89018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89019       };
89020     }
89021   }
89022
89023   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
89024   return jresult;
89025 }
89026
89027
89028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
89029   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89030   Dali::Actor arg2 ;
89031   Dali::Actor *argp2 ;
89032
89033   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89034   argp2 = (Dali::Actor *)jarg2;
89035   if (!argp2) {
89036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89037     return ;
89038   }
89039   arg2 = *argp2;
89040   {
89041     try {
89042       (arg1)->Add(arg2);
89043     } catch (std::out_of_range& e) {
89044       {
89045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89046       };
89047     } catch (std::exception& e) {
89048       {
89049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89050       };
89051     } catch (Dali::DaliException e) {
89052       {
89053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89054       };
89055     } catch (...) {
89056       {
89057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89058       };
89059     }
89060   }
89061
89062 }
89063
89064
89065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89066   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89067   Dali::Actor arg2 ;
89068   Dali::Actor *argp2 ;
89069
89070   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89071   argp2 = (Dali::Actor *)jarg2;
89072   if (!argp2) {
89073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89074     return ;
89075   }
89076   arg2 = *argp2;
89077   {
89078     try {
89079       (arg1)->Remove(arg2);
89080     } catch (std::out_of_range& e) {
89081       {
89082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89083       };
89084     } catch (std::exception& e) {
89085       {
89086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89087       };
89088     } catch (Dali::DaliException e) {
89089       {
89090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89091       };
89092     } catch (...) {
89093       {
89094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89095       };
89096     }
89097   }
89098
89099 }
89100
89101
89102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89103   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89104
89105   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89106   {
89107     try {
89108       (arg1)->Activate();
89109     } catch (std::out_of_range& e) {
89110       {
89111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89112       };
89113     } catch (std::exception& e) {
89114       {
89115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89116       };
89117     } catch (Dali::DaliException e) {
89118       {
89119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89120       };
89121     } catch (...) {
89122       {
89123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89124       };
89125     }
89126   }
89127
89128 }
89129
89130
89131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89132   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89133
89134   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89135   {
89136     try {
89137       (arg1)->ActivateOnce();
89138     } catch (std::out_of_range& e) {
89139       {
89140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89141       };
89142     } catch (std::exception& e) {
89143       {
89144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89145       };
89146     } catch (Dali::DaliException e) {
89147       {
89148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89149       };
89150     } catch (...) {
89151       {
89152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89153       };
89154     }
89155   }
89156
89157 }
89158
89159
89160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89161   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89162
89163   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89164   {
89165     try {
89166       (arg1)->Deactivate();
89167     } catch (std::out_of_range& e) {
89168       {
89169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89170       };
89171     } catch (std::exception& e) {
89172       {
89173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89174       };
89175     } catch (Dali::DaliException e) {
89176       {
89177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89178       };
89179     } catch (...) {
89180       {
89181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89182       };
89183     }
89184   }
89185
89186 }
89187
89188
89189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89190   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89191   Dali::Image arg2 ;
89192   Dali::FrameBufferImage arg3 ;
89193   Dali::Image *argp2 ;
89194   Dali::FrameBufferImage *argp3 ;
89195
89196   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89197   argp2 = (Dali::Image *)jarg2;
89198   if (!argp2) {
89199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89200     return ;
89201   }
89202   arg2 = *argp2;
89203   argp3 = (Dali::FrameBufferImage *)jarg3;
89204   if (!argp3) {
89205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89206     return ;
89207   }
89208   arg3 = *argp3;
89209   {
89210     try {
89211       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89212     } catch (std::out_of_range& e) {
89213       {
89214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89215       };
89216     } catch (std::exception& e) {
89217       {
89218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89219       };
89220     } catch (Dali::DaliException e) {
89221       {
89222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89223       };
89224     } catch (...) {
89225       {
89226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89227       };
89228     }
89229   }
89230
89231 }
89232
89233
89234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89235   int jresult ;
89236   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89237   Dali::Property::Index result;
89238
89239   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89240   {
89241     try {
89242       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89243     } catch (std::out_of_range& e) {
89244       {
89245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89246       };
89247     } catch (std::exception& e) {
89248       {
89249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89250       };
89251     } catch (Dali::DaliException e) {
89252       {
89253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89254       };
89255     } catch (...) {
89256       {
89257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89258       };
89259     }
89260   }
89261
89262   jresult = result;
89263   return jresult;
89264 }
89265
89266
89267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89268   void * jresult ;
89269   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89270   Dali::FrameBufferImage result;
89271
89272   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89273   {
89274     try {
89275       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89276     } catch (std::out_of_range& e) {
89277       {
89278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89279       };
89280     } catch (std::exception& e) {
89281       {
89282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89283       };
89284     } catch (Dali::DaliException e) {
89285       {
89286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89287       };
89288     } catch (...) {
89289       {
89290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89291       };
89292     }
89293   }
89294
89295   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89296   return jresult;
89297 }
89298
89299
89300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89301   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89302   Dali::Vector4 *arg2 = 0 ;
89303
89304   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89305   arg2 = (Dali::Vector4 *)jarg2;
89306   if (!arg2) {
89307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89308     return ;
89309   }
89310   {
89311     try {
89312       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89313     } catch (std::out_of_range& e) {
89314       {
89315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89316       };
89317     } catch (std::exception& e) {
89318       {
89319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89320       };
89321     } catch (Dali::DaliException e) {
89322       {
89323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89324       };
89325     } catch (...) {
89326       {
89327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89328       };
89329     }
89330   }
89331
89332 }
89333
89334
89335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89336   void * jresult ;
89337   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89338   Dali::Vector4 result;
89339
89340   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89341   {
89342     try {
89343       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89344     } catch (std::out_of_range& e) {
89345       {
89346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89347       };
89348     } catch (std::exception& e) {
89349       {
89350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89351       };
89352     } catch (Dali::DaliException e) {
89353       {
89354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89355       };
89356     } catch (...) {
89357       {
89358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89359       };
89360     }
89361   }
89362
89363   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89364   return jresult;
89365 }
89366
89367
89368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89369   void * jresult ;
89370   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89371   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89372
89373   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89374   {
89375     try {
89376       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89377     } catch (std::out_of_range& e) {
89378       {
89379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89380       };
89381     } catch (std::exception& e) {
89382       {
89383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89384       };
89385     } catch (Dali::DaliException e) {
89386       {
89387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89388       };
89389     } catch (...) {
89390       {
89391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89392       };
89393     }
89394   }
89395
89396   jresult = (void *)result;
89397   return jresult;
89398 }
89399
89400
89401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89402   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89403
89404   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89405   {
89406     try {
89407       delete arg1;
89408     } catch (std::out_of_range& e) {
89409       {
89410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89411       };
89412     } catch (std::exception& e) {
89413       {
89414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89415       };
89416     } catch (Dali::DaliException e) {
89417       {
89418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89419       };
89420     } catch (...) {
89421       {
89422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89423       };
89424     }
89425   }
89426
89427 }
89428
89429
89430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89431   unsigned int jresult ;
89432   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89433   unsigned int result;
89434
89435   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89436   {
89437     try {
89438       result = (unsigned int)(arg1)->GetNumberOfPages();
89439     } catch (std::out_of_range& e) {
89440       {
89441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89442       };
89443     } catch (std::exception& e) {
89444       {
89445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89446       };
89447     } catch (Dali::DaliException e) {
89448       {
89449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89450       };
89451     } catch (...) {
89452       {
89453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89454       };
89455     }
89456   }
89457
89458   jresult = result;
89459   return jresult;
89460 }
89461
89462
89463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89464   void * jresult ;
89465   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89466   unsigned int arg2 ;
89467   Dali::Texture result;
89468
89469   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89470   arg2 = (unsigned int)jarg2;
89471   {
89472     try {
89473       result = (arg1)->NewPage(arg2);
89474     } catch (std::out_of_range& e) {
89475       {
89476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89477       };
89478     } catch (std::exception& e) {
89479       {
89480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89481       };
89482     } catch (Dali::DaliException e) {
89483       {
89484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89485       };
89486     } catch (...) {
89487       {
89488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89489       };
89490     }
89491   }
89492
89493   jresult = new Dali::Texture((const Dali::Texture &)result);
89494   return jresult;
89495 }
89496
89497
89498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89499   int jresult ;
89500   int result;
89501
89502   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89503   jresult = (int)result;
89504   return jresult;
89505 }
89506
89507
89508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89509   int jresult ;
89510   int result;
89511
89512   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89513   jresult = (int)result;
89514   return jresult;
89515 }
89516
89517
89518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89519   int jresult ;
89520   int result;
89521
89522   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89523   jresult = (int)result;
89524   return jresult;
89525 }
89526
89527
89528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89529   void * jresult ;
89530   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89531
89532   {
89533     try {
89534       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89535     } catch (std::out_of_range& e) {
89536       {
89537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89538       };
89539     } catch (std::exception& e) {
89540       {
89541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89542       };
89543     } catch (Dali::DaliException e) {
89544       {
89545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89546       };
89547     } catch (...) {
89548       {
89549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89550       };
89551     }
89552   }
89553
89554   jresult = (void *)result;
89555   return jresult;
89556 }
89557
89558
89559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89560   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89561
89562   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89563   {
89564     try {
89565       delete arg1;
89566     } catch (std::out_of_range& e) {
89567       {
89568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89569       };
89570     } catch (std::exception& e) {
89571       {
89572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89573       };
89574     } catch (Dali::DaliException e) {
89575       {
89576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89577       };
89578     } catch (...) {
89579       {
89580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89581       };
89582     }
89583   }
89584
89585 }
89586
89587
89588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89589   void * jresult ;
89590   Dali::Toolkit::PageTurnView *result = 0 ;
89591
89592   {
89593     try {
89594       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89595     } catch (std::out_of_range& e) {
89596       {
89597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89598       };
89599     } catch (std::exception& e) {
89600       {
89601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89602       };
89603     } catch (Dali::DaliException e) {
89604       {
89605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89606       };
89607     } catch (...) {
89608       {
89609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89610       };
89611     }
89612   }
89613
89614   jresult = (void *)result;
89615   return jresult;
89616 }
89617
89618
89619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89620   void * jresult ;
89621   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89622   Dali::Toolkit::PageTurnView *result = 0 ;
89623
89624   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89625   if (!arg1) {
89626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89627     return 0;
89628   }
89629   {
89630     try {
89631       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89632     } catch (std::out_of_range& e) {
89633       {
89634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89635       };
89636     } catch (std::exception& e) {
89637       {
89638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89639       };
89640     } catch (Dali::DaliException e) {
89641       {
89642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89643       };
89644     } catch (...) {
89645       {
89646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89647       };
89648     }
89649   }
89650
89651   jresult = (void *)result;
89652   return jresult;
89653 }
89654
89655
89656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89657   void * jresult ;
89658   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89659   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89660   Dali::Toolkit::PageTurnView *result = 0 ;
89661
89662   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89663   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89664   if (!arg2) {
89665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89666     return 0;
89667   }
89668   {
89669     try {
89670       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89671     } catch (std::out_of_range& e) {
89672       {
89673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89674       };
89675     } catch (std::exception& e) {
89676       {
89677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89678       };
89679     } catch (Dali::DaliException e) {
89680       {
89681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89682       };
89683     } catch (...) {
89684       {
89685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89686       };
89687     }
89688   }
89689
89690   jresult = (void *)result;
89691   return jresult;
89692 }
89693
89694
89695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89696   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89697
89698   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89699   {
89700     try {
89701       delete arg1;
89702     } catch (std::out_of_range& e) {
89703       {
89704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89705       };
89706     } catch (std::exception& e) {
89707       {
89708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89709       };
89710     } catch (Dali::DaliException e) {
89711       {
89712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89713       };
89714     } catch (...) {
89715       {
89716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89717       };
89718     }
89719   }
89720
89721 }
89722
89723
89724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
89725   void * jresult ;
89726   Dali::BaseHandle arg1 ;
89727   Dali::BaseHandle *argp1 ;
89728   Dali::Toolkit::PageTurnView result;
89729
89730   argp1 = (Dali::BaseHandle *)jarg1;
89731   if (!argp1) {
89732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89733     return 0;
89734   }
89735   arg1 = *argp1;
89736   {
89737     try {
89738       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89739     } catch (std::out_of_range& e) {
89740       {
89741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89742       };
89743     } catch (std::exception& e) {
89744       {
89745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89746       };
89747     } catch (Dali::DaliException e) {
89748       {
89749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89750       };
89751     } catch (...) {
89752       {
89753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89754       };
89755     }
89756   }
89757
89758   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89759   return jresult;
89760 }
89761
89762
89763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89764   void * jresult ;
89765   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89766   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89767
89768   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89769   {
89770     try {
89771       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89772     } catch (std::out_of_range& e) {
89773       {
89774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89775       };
89776     } catch (std::exception& e) {
89777       {
89778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89779       };
89780     } catch (Dali::DaliException e) {
89781       {
89782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89783       };
89784     } catch (...) {
89785       {
89786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89787       };
89788     }
89789   }
89790
89791   jresult = (void *)result;
89792   return jresult;
89793 }
89794
89795
89796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89797   void * jresult ;
89798   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89799   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89800
89801   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89802   {
89803     try {
89804       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89805     } catch (std::out_of_range& e) {
89806       {
89807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89808       };
89809     } catch (std::exception& e) {
89810       {
89811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89812       };
89813     } catch (Dali::DaliException e) {
89814       {
89815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89816       };
89817     } catch (...) {
89818       {
89819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89820       };
89821     }
89822   }
89823
89824   jresult = (void *)result;
89825   return jresult;
89826 }
89827
89828
89829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89830   void * jresult ;
89831   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89832   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89833
89834   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89835   {
89836     try {
89837       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89838     } catch (std::out_of_range& e) {
89839       {
89840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89841       };
89842     } catch (std::exception& e) {
89843       {
89844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89845       };
89846     } catch (Dali::DaliException e) {
89847       {
89848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89849       };
89850     } catch (...) {
89851       {
89852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89853       };
89854     }
89855   }
89856
89857   jresult = (void *)result;
89858   return jresult;
89859 }
89860
89861
89862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89863   void * jresult ;
89864   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89865   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89866
89867   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89868   {
89869     try {
89870       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89871     } catch (std::out_of_range& e) {
89872       {
89873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89874       };
89875     } catch (std::exception& e) {
89876       {
89877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89878       };
89879     } catch (Dali::DaliException e) {
89880       {
89881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89882       };
89883     } catch (...) {
89884       {
89885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89886       };
89887     }
89888   }
89889
89890   jresult = (void *)result;
89891   return jresult;
89892 }
89893
89894
89895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89896   void * jresult ;
89897   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89898
89899   {
89900     try {
89901       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89902     } catch (std::out_of_range& e) {
89903       {
89904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89905       };
89906     } catch (std::exception& e) {
89907       {
89908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89909       };
89910     } catch (Dali::DaliException e) {
89911       {
89912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89913       };
89914     } catch (...) {
89915       {
89916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89917       };
89918     }
89919   }
89920
89921   jresult = (void *)result;
89922   return jresult;
89923 }
89924
89925
89926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89927   void * jresult ;
89928   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89929   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89930
89931   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89932   if (!arg1) {
89933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89934     return 0;
89935   }
89936   {
89937     try {
89938       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89939     } catch (std::out_of_range& e) {
89940       {
89941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89942       };
89943     } catch (std::exception& e) {
89944       {
89945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89946       };
89947     } catch (Dali::DaliException e) {
89948       {
89949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89950       };
89951     } catch (...) {
89952       {
89953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89954       };
89955     }
89956   }
89957
89958   jresult = (void *)result;
89959   return jresult;
89960 }
89961
89962
89963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89964   void * jresult ;
89965   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89966   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89967   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89968
89969   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89970   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89971   if (!arg2) {
89972     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89973     return 0;
89974   }
89975   {
89976     try {
89977       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89978     } catch (std::out_of_range& e) {
89979       {
89980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89981       };
89982     } catch (std::exception& e) {
89983       {
89984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89985       };
89986     } catch (Dali::DaliException e) {
89987       {
89988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89989       };
89990     } catch (...) {
89991       {
89992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89993       };
89994     }
89995   }
89996
89997   jresult = (void *)result;
89998   return jresult;
89999 }
90000
90001
90002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
90003   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
90004
90005   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
90006   {
90007     try {
90008       delete arg1;
90009     } catch (std::out_of_range& e) {
90010       {
90011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90012       };
90013     } catch (std::exception& e) {
90014       {
90015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90016       };
90017     } catch (Dali::DaliException e) {
90018       {
90019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90020       };
90021     } catch (...) {
90022       {
90023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90024       };
90025     }
90026   }
90027
90028 }
90029
90030
90031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
90032   void * jresult ;
90033   Dali::Toolkit::PageFactory *arg1 = 0 ;
90034   Dali::Vector2 *arg2 = 0 ;
90035   Dali::Toolkit::PageTurnLandscapeView result;
90036
90037   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90038   if (!arg1) {
90039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90040     return 0;
90041   }
90042   arg2 = (Dali::Vector2 *)jarg2;
90043   if (!arg2) {
90044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90045     return 0;
90046   }
90047   {
90048     try {
90049       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90050     } catch (std::out_of_range& e) {
90051       {
90052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90053       };
90054     } catch (std::exception& e) {
90055       {
90056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90057       };
90058     } catch (Dali::DaliException e) {
90059       {
90060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90061       };
90062     } catch (...) {
90063       {
90064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90065       };
90066     }
90067   }
90068
90069   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90070   return jresult;
90071 }
90072
90073
90074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90075   void * jresult ;
90076   Dali::BaseHandle arg1 ;
90077   Dali::BaseHandle *argp1 ;
90078   Dali::Toolkit::PageTurnLandscapeView result;
90079
90080   argp1 = (Dali::BaseHandle *)jarg1;
90081   if (!argp1) {
90082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90083     return 0;
90084   }
90085   arg1 = *argp1;
90086   {
90087     try {
90088       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90089     } catch (std::out_of_range& e) {
90090       {
90091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90092       };
90093     } catch (std::exception& e) {
90094       {
90095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90096       };
90097     } catch (Dali::DaliException e) {
90098       {
90099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90100       };
90101     } catch (...) {
90102       {
90103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90104       };
90105     }
90106   }
90107
90108   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90109   return jresult;
90110 }
90111
90112
90113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90114   void * jresult ;
90115   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90116
90117   {
90118     try {
90119       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90120     } catch (std::out_of_range& e) {
90121       {
90122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90123       };
90124     } catch (std::exception& e) {
90125       {
90126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90127       };
90128     } catch (Dali::DaliException e) {
90129       {
90130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90131       };
90132     } catch (...) {
90133       {
90134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90135       };
90136     }
90137   }
90138
90139   jresult = (void *)result;
90140   return jresult;
90141 }
90142
90143
90144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90145   void * jresult ;
90146   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90147   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90148
90149   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90150   if (!arg1) {
90151     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90152     return 0;
90153   }
90154   {
90155     try {
90156       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90157     } catch (std::out_of_range& e) {
90158       {
90159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90160       };
90161     } catch (std::exception& e) {
90162       {
90163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90164       };
90165     } catch (Dali::DaliException e) {
90166       {
90167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90168       };
90169     } catch (...) {
90170       {
90171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90172       };
90173     }
90174   }
90175
90176   jresult = (void *)result;
90177   return jresult;
90178 }
90179
90180
90181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90182   void * jresult ;
90183   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90184   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90185   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90186
90187   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90188   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90189   if (!arg2) {
90190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90191     return 0;
90192   }
90193   {
90194     try {
90195       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90196     } catch (std::out_of_range& e) {
90197       {
90198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90199       };
90200     } catch (std::exception& e) {
90201       {
90202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90203       };
90204     } catch (Dali::DaliException e) {
90205       {
90206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90207       };
90208     } catch (...) {
90209       {
90210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90211       };
90212     }
90213   }
90214
90215   jresult = (void *)result;
90216   return jresult;
90217 }
90218
90219
90220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90221   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90222
90223   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90224   {
90225     try {
90226       delete arg1;
90227     } catch (std::out_of_range& e) {
90228       {
90229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90230       };
90231     } catch (std::exception& e) {
90232       {
90233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90234       };
90235     } catch (Dali::DaliException e) {
90236       {
90237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90238       };
90239     } catch (...) {
90240       {
90241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90242       };
90243     }
90244   }
90245
90246 }
90247
90248
90249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90250   void * jresult ;
90251   Dali::Toolkit::PageFactory *arg1 = 0 ;
90252   Dali::Vector2 *arg2 = 0 ;
90253   Dali::Toolkit::PageTurnPortraitView result;
90254
90255   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90256   if (!arg1) {
90257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90258     return 0;
90259   }
90260   arg2 = (Dali::Vector2 *)jarg2;
90261   if (!arg2) {
90262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90263     return 0;
90264   }
90265   {
90266     try {
90267       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90268     } catch (std::out_of_range& e) {
90269       {
90270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90271       };
90272     } catch (std::exception& e) {
90273       {
90274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90275       };
90276     } catch (Dali::DaliException e) {
90277       {
90278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90279       };
90280     } catch (...) {
90281       {
90282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90283       };
90284     }
90285   }
90286
90287   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90288   return jresult;
90289 }
90290
90291
90292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90293   void * jresult ;
90294   Dali::BaseHandle arg1 ;
90295   Dali::BaseHandle *argp1 ;
90296   Dali::Toolkit::PageTurnPortraitView result;
90297
90298   argp1 = (Dali::BaseHandle *)jarg1;
90299   if (!argp1) {
90300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90301     return 0;
90302   }
90303   arg1 = *argp1;
90304   {
90305     try {
90306       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90307     } catch (std::out_of_range& e) {
90308       {
90309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90310       };
90311     } catch (std::exception& e) {
90312       {
90313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90314       };
90315     } catch (Dali::DaliException e) {
90316       {
90317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90318       };
90319     } catch (...) {
90320       {
90321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90322       };
90323     }
90324   }
90325
90326   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90327   return jresult;
90328 }
90329
90330
90331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90332   int jresult ;
90333   int result;
90334
90335   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90336   jresult = (int)result;
90337   return jresult;
90338 }
90339
90340
90341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90342   int jresult ;
90343   int result;
90344
90345   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90346   jresult = (int)result;
90347   return jresult;
90348 }
90349
90350
90351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90352   int jresult ;
90353   int result;
90354
90355   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90356   jresult = (int)result;
90357   return jresult;
90358 }
90359
90360
90361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90362   void * jresult ;
90363   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90364
90365   {
90366     try {
90367       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90368     } catch (std::out_of_range& e) {
90369       {
90370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90371       };
90372     } catch (std::exception& e) {
90373       {
90374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90375       };
90376     } catch (Dali::DaliException e) {
90377       {
90378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90379       };
90380     } catch (...) {
90381       {
90382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90383       };
90384     }
90385   }
90386
90387   jresult = (void *)result;
90388   return jresult;
90389 }
90390
90391
90392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90393   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90394
90395   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90396   {
90397     try {
90398       delete arg1;
90399     } catch (std::out_of_range& e) {
90400       {
90401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90402       };
90403     } catch (std::exception& e) {
90404       {
90405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90406       };
90407     } catch (Dali::DaliException e) {
90408       {
90409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90410       };
90411     } catch (...) {
90412       {
90413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90414       };
90415     }
90416   }
90417
90418 }
90419
90420
90421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90422   void * jresult ;
90423   Dali::Toolkit::ToggleButton *result = 0 ;
90424
90425   {
90426     try {
90427       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90428     } catch (std::out_of_range& e) {
90429       {
90430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90431       };
90432     } catch (std::exception& e) {
90433       {
90434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90435       };
90436     } catch (Dali::DaliException e) {
90437       {
90438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90439       };
90440     } catch (...) {
90441       {
90442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90443       };
90444     }
90445   }
90446
90447   jresult = (void *)result;
90448   return jresult;
90449 }
90450
90451
90452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90453   void * jresult ;
90454   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90455   Dali::Toolkit::ToggleButton *result = 0 ;
90456
90457   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90458   if (!arg1) {
90459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90460     return 0;
90461   }
90462   {
90463     try {
90464       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90465     } catch (std::out_of_range& e) {
90466       {
90467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90468       };
90469     } catch (std::exception& e) {
90470       {
90471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90472       };
90473     } catch (Dali::DaliException e) {
90474       {
90475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90476       };
90477     } catch (...) {
90478       {
90479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90480       };
90481     }
90482   }
90483
90484   jresult = (void *)result;
90485   return jresult;
90486 }
90487
90488
90489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90490   void * jresult ;
90491   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90492   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90493   Dali::Toolkit::ToggleButton *result = 0 ;
90494
90495   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90496   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90497   if (!arg2) {
90498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90499     return 0;
90500   }
90501   {
90502     try {
90503       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90504     } catch (std::out_of_range& e) {
90505       {
90506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90507       };
90508     } catch (std::exception& e) {
90509       {
90510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90511       };
90512     } catch (Dali::DaliException e) {
90513       {
90514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90515       };
90516     } catch (...) {
90517       {
90518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90519       };
90520     }
90521   }
90522
90523   jresult = (void *)result;
90524   return jresult;
90525 }
90526
90527
90528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90529   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90530
90531   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90532   {
90533     try {
90534       delete arg1;
90535     } catch (std::out_of_range& e) {
90536       {
90537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90538       };
90539     } catch (std::exception& e) {
90540       {
90541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90542       };
90543     } catch (Dali::DaliException e) {
90544       {
90545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90546       };
90547     } catch (...) {
90548       {
90549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90550       };
90551     }
90552   }
90553
90554 }
90555
90556
90557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90558   void * jresult ;
90559   Dali::Toolkit::ToggleButton result;
90560
90561   {
90562     try {
90563       result = Dali::Toolkit::ToggleButton::New();
90564     } catch (std::out_of_range& e) {
90565       {
90566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90567       };
90568     } catch (std::exception& e) {
90569       {
90570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90571       };
90572     } catch (Dali::DaliException e) {
90573       {
90574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90575       };
90576     } catch (...) {
90577       {
90578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90579       };
90580     }
90581   }
90582
90583   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90584   return jresult;
90585 }
90586
90587
90588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90589   void * jresult ;
90590   Dali::BaseHandle arg1 ;
90591   Dali::BaseHandle *argp1 ;
90592   Dali::Toolkit::ToggleButton result;
90593
90594   argp1 = (Dali::BaseHandle *)jarg1;
90595   if (!argp1) {
90596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90597     return 0;
90598   }
90599   arg1 = *argp1;
90600   {
90601     try {
90602       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90603     } catch (std::out_of_range& e) {
90604       {
90605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90606       };
90607     } catch (std::exception& e) {
90608       {
90609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90610       };
90611     } catch (Dali::DaliException e) {
90612       {
90613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90614       };
90615     } catch (...) {
90616       {
90617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90618       };
90619     }
90620   }
90621
90622   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90623   return jresult;
90624 }
90625
90626
90627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90628   void * jresult ;
90629   Dali::Toolkit::Visual::Base *result = 0 ;
90630
90631   {
90632     try {
90633       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90634     } catch (std::out_of_range& e) {
90635       {
90636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90637       };
90638     } catch (std::exception& e) {
90639       {
90640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90641       };
90642     } catch (Dali::DaliException e) {
90643       {
90644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90645       };
90646     } catch (...) {
90647       {
90648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90649       };
90650     }
90651   }
90652
90653   jresult = (void *)result;
90654   return jresult;
90655 }
90656
90657
90658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90659   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90660
90661   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90662   {
90663     try {
90664       delete arg1;
90665     } catch (std::out_of_range& e) {
90666       {
90667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90668       };
90669     } catch (std::exception& e) {
90670       {
90671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90672       };
90673     } catch (Dali::DaliException e) {
90674       {
90675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90676       };
90677     } catch (...) {
90678       {
90679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90680       };
90681     }
90682   }
90683
90684 }
90685
90686
90687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90688   void * jresult ;
90689   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90690   Dali::Toolkit::Visual::Base *result = 0 ;
90691
90692   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90693   if (!arg1) {
90694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90695     return 0;
90696   }
90697   {
90698     try {
90699       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90700     } catch (std::out_of_range& e) {
90701       {
90702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90703       };
90704     } catch (std::exception& e) {
90705       {
90706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90707       };
90708     } catch (Dali::DaliException e) {
90709       {
90710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90711       };
90712     } catch (...) {
90713       {
90714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90715       };
90716     }
90717   }
90718
90719   jresult = (void *)result;
90720   return jresult;
90721 }
90722
90723
90724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
90725   void * jresult ;
90726   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90727   Dali::Toolkit::Visual::Base *arg2 = 0 ;
90728   Dali::Toolkit::Visual::Base *result = 0 ;
90729
90730   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90731   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90732   if (!arg2) {
90733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90734     return 0;
90735   }
90736   {
90737     try {
90738       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90739     } catch (std::out_of_range& e) {
90740       {
90741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90742       };
90743     } catch (std::exception& e) {
90744       {
90745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90746       };
90747     } catch (Dali::DaliException e) {
90748       {
90749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90750       };
90751     } catch (...) {
90752       {
90753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90754       };
90755     }
90756   }
90757
90758   jresult = (void *)result;
90759   return jresult;
90760 }
90761
90762
90763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90764   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90765   std::string *arg2 = 0 ;
90766
90767   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90768   if (!jarg2) {
90769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90770     return ;
90771   }
90772   std::string arg2_str(jarg2);
90773   arg2 = &arg2_str;
90774   {
90775     try {
90776       (arg1)->SetName((std::string const &)*arg2);
90777     } catch (std::out_of_range& e) {
90778       {
90779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90780       };
90781     } catch (std::exception& e) {
90782       {
90783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90784       };
90785     } catch (Dali::DaliException e) {
90786       {
90787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90788       };
90789     } catch (...) {
90790       {
90791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90792       };
90793     }
90794   }
90795
90796
90797   //argout typemap for const std::string&
90798
90799 }
90800
90801
90802 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90803   char * jresult ;
90804   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90805   std::string *result = 0 ;
90806
90807   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90808   {
90809     try {
90810       result = (std::string *) &(arg1)->GetName();
90811     } catch (std::out_of_range& e) {
90812       {
90813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90814       };
90815     } catch (std::exception& e) {
90816       {
90817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90818       };
90819     } catch (Dali::DaliException e) {
90820       {
90821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90822       };
90823     } catch (...) {
90824       {
90825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90826       };
90827     }
90828   }
90829
90830   jresult = SWIG_csharp_string_callback(result->c_str());
90831   return jresult;
90832 }
90833
90834
90835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90836   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90837   Dali::Property::Map *arg2 = 0 ;
90838   Dali::Size arg3 ;
90839   Dali::Size *argp3 ;
90840
90841   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90842   arg2 = (Dali::Property::Map *)jarg2;
90843   if (!arg2) {
90844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90845     return ;
90846   }
90847   argp3 = (Dali::Size *)jarg3;
90848   if (!argp3) {
90849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90850     return ;
90851   }
90852   arg3 = *argp3;
90853   {
90854     try {
90855       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90856     } catch (std::out_of_range& e) {
90857       {
90858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90859       };
90860     } catch (std::exception& e) {
90861       {
90862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90863       };
90864     } catch (Dali::DaliException e) {
90865       {
90866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90867       };
90868     } catch (...) {
90869       {
90870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90871       };
90872     }
90873   }
90874
90875 }
90876
90877
90878 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90879   float jresult ;
90880   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90881   float arg2 ;
90882   float result;
90883
90884   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90885   arg2 = (float)jarg2;
90886   {
90887     try {
90888       result = (float)(arg1)->GetHeightForWidth(arg2);
90889     } catch (std::out_of_range& e) {
90890       {
90891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90892       };
90893     } catch (std::exception& e) {
90894       {
90895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90896       };
90897     } catch (Dali::DaliException e) {
90898       {
90899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90900       };
90901     } catch (...) {
90902       {
90903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90904       };
90905     }
90906   }
90907
90908   jresult = result;
90909   return jresult;
90910 }
90911
90912
90913 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90914   float jresult ;
90915   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90916   float arg2 ;
90917   float result;
90918
90919   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90920   arg2 = (float)jarg2;
90921   {
90922     try {
90923       result = (float)(arg1)->GetWidthForHeight(arg2);
90924     } catch (std::out_of_range& e) {
90925       {
90926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90927       };
90928     } catch (std::exception& e) {
90929       {
90930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90931       };
90932     } catch (Dali::DaliException e) {
90933       {
90934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90935       };
90936     } catch (...) {
90937       {
90938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90939       };
90940     }
90941   }
90942
90943   jresult = result;
90944   return jresult;
90945 }
90946
90947
90948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90949   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90950   Dali::Vector2 *arg2 = 0 ;
90951
90952   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90953   arg2 = (Dali::Vector2 *)jarg2;
90954   if (!arg2) {
90955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90956     return ;
90957   }
90958   {
90959     try {
90960       (arg1)->GetNaturalSize(*arg2);
90961     } catch (std::out_of_range& e) {
90962       {
90963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90964       };
90965     } catch (std::exception& e) {
90966       {
90967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90968       };
90969     } catch (Dali::DaliException e) {
90970       {
90971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90972       };
90973     } catch (...) {
90974       {
90975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90976       };
90977     }
90978   }
90979
90980 }
90981
90982
90983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90984   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90985   float arg2 ;
90986
90987   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90988   arg2 = (int)jarg2;
90989   {
90990     try {
90991       (arg1)->SetDepthIndex(arg2);
90992     } catch (std::out_of_range& e) {
90993       {
90994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90995       };
90996     } catch (std::exception& e) {
90997       {
90998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90999       };
91000     } catch (Dali::DaliException e) {
91001       {
91002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91003       };
91004     } catch (...) {
91005       {
91006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91007       };
91008     }
91009   }
91010
91011 }
91012
91013
91014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
91015   int jresult ;
91016   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91017   int result;
91018
91019   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91020   {
91021     try {
91022       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
91023     } catch (std::out_of_range& e) {
91024       {
91025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91026       };
91027     } catch (std::exception& e) {
91028       {
91029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91030       };
91031     } catch (Dali::DaliException e) {
91032       {
91033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91034       };
91035     } catch (...) {
91036       {
91037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91038       };
91039     }
91040   }
91041
91042   jresult = result;
91043   return jresult;
91044 }
91045
91046
91047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91048   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91049   Dali::Property::Map *arg2 = 0 ;
91050
91051   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91052   arg2 = (Dali::Property::Map *)jarg2;
91053   if (!arg2) {
91054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91055     return ;
91056   }
91057   {
91058     try {
91059       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91060     } catch (std::out_of_range& e) {
91061       {
91062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91063       };
91064     } catch (std::exception& e) {
91065       {
91066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91067       };
91068     } catch (Dali::DaliException e) {
91069       {
91070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91071       };
91072     } catch (...) {
91073       {
91074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91075       };
91076     }
91077   }
91078
91079 }
91080
91081
91082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91083   void * jresult ;
91084   Dali::Toolkit::VisualFactory result;
91085
91086   {
91087     try {
91088       result = Dali::Toolkit::VisualFactory::Get();
91089     } catch (std::out_of_range& e) {
91090       {
91091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91092       };
91093     } catch (std::exception& e) {
91094       {
91095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91096       };
91097     } catch (Dali::DaliException e) {
91098       {
91099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91100       };
91101     } catch (...) {
91102       {
91103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91104       };
91105     }
91106   }
91107
91108   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91109   return jresult;
91110 }
91111
91112
91113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91114   void * jresult ;
91115   Dali::Toolkit::VisualFactory *result = 0 ;
91116
91117   {
91118     try {
91119       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91120     } catch (std::out_of_range& e) {
91121       {
91122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91123       };
91124     } catch (std::exception& e) {
91125       {
91126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91127       };
91128     } catch (Dali::DaliException e) {
91129       {
91130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91131       };
91132     } catch (...) {
91133       {
91134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91135       };
91136     }
91137   }
91138
91139   jresult = (void *)result;
91140   return jresult;
91141 }
91142
91143
91144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91145   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91146
91147   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91148   {
91149     try {
91150       delete arg1;
91151     } catch (std::out_of_range& e) {
91152       {
91153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91154       };
91155     } catch (std::exception& e) {
91156       {
91157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91158       };
91159     } catch (Dali::DaliException e) {
91160       {
91161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91162       };
91163     } catch (...) {
91164       {
91165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91166       };
91167     }
91168   }
91169
91170 }
91171
91172
91173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91174   void * jresult ;
91175   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91176   Dali::Toolkit::VisualFactory *result = 0 ;
91177
91178   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91179   if (!arg1) {
91180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91181     return 0;
91182   }
91183   {
91184     try {
91185       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91186     } catch (std::out_of_range& e) {
91187       {
91188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91189       };
91190     } catch (std::exception& e) {
91191       {
91192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91193       };
91194     } catch (Dali::DaliException e) {
91195       {
91196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91197       };
91198     } catch (...) {
91199       {
91200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91201       };
91202     }
91203   }
91204
91205   jresult = (void *)result;
91206   return jresult;
91207 }
91208
91209
91210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91211   void * jresult ;
91212   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91213   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91214   Dali::Toolkit::VisualFactory *result = 0 ;
91215
91216   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91217   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91218   if (!arg2) {
91219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91220     return 0;
91221   }
91222   {
91223     try {
91224       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91225     } catch (std::out_of_range& e) {
91226       {
91227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91228       };
91229     } catch (std::exception& e) {
91230       {
91231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91232       };
91233     } catch (Dali::DaliException e) {
91234       {
91235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91236       };
91237     } catch (...) {
91238       {
91239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91240       };
91241     }
91242   }
91243
91244   jresult = (void *)result;
91245   return jresult;
91246 }
91247
91248
91249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91250   void * jresult ;
91251   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91252   Dali::Property::Map *arg2 = 0 ;
91253   Dali::Toolkit::Visual::Base result;
91254
91255   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91256   arg2 = (Dali::Property::Map *)jarg2;
91257   if (!arg2) {
91258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91259     return 0;
91260   }
91261   {
91262     try {
91263       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91264     } catch (std::out_of_range& e) {
91265       {
91266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91267       };
91268     } catch (std::exception& e) {
91269       {
91270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91271       };
91272     } catch (Dali::DaliException e) {
91273       {
91274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91275       };
91276     } catch (...) {
91277       {
91278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91279       };
91280     }
91281   }
91282
91283   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91284   return jresult;
91285 }
91286
91287
91288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91289   void * jresult ;
91290   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91291   Dali::Image *arg2 = 0 ;
91292   Dali::Toolkit::Visual::Base result;
91293
91294   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91295   arg2 = (Dali::Image *)jarg2;
91296   if (!arg2) {
91297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91298     return 0;
91299   }
91300   {
91301     try {
91302       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91303     } catch (std::out_of_range& e) {
91304       {
91305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91306       };
91307     } catch (std::exception& e) {
91308       {
91309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91310       };
91311     } catch (Dali::DaliException e) {
91312       {
91313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91314       };
91315     } catch (...) {
91316       {
91317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91318       };
91319     }
91320   }
91321
91322   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91323   return jresult;
91324 }
91325
91326
91327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91328   void * jresult ;
91329   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91330   std::string *arg2 = 0 ;
91331   Dali::ImageDimensions arg3 ;
91332   Dali::ImageDimensions *argp3 ;
91333   Dali::Toolkit::Visual::Base result;
91334
91335   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91336   if (!jarg2) {
91337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91338     return 0;
91339   }
91340   std::string arg2_str(jarg2);
91341   arg2 = &arg2_str;
91342   argp3 = (Dali::ImageDimensions *)jarg3;
91343   if (!argp3) {
91344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91345     return 0;
91346   }
91347   arg3 = *argp3;
91348   {
91349     try {
91350       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91351     } catch (std::out_of_range& e) {
91352       {
91353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91354       };
91355     } catch (std::exception& e) {
91356       {
91357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91358       };
91359     } catch (Dali::DaliException e) {
91360       {
91361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91362       };
91363     } catch (...) {
91364       {
91365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91366       };
91367     }
91368   }
91369
91370   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91371
91372   //argout typemap for const std::string&
91373
91374   return jresult;
91375 }
91376
91377
91378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91379   void * jresult ;
91380   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91381
91382   {
91383     try {
91384       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91385     } catch (std::out_of_range& e) {
91386       {
91387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91388       };
91389     } catch (std::exception& e) {
91390       {
91391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91392       };
91393     } catch (Dali::DaliException e) {
91394       {
91395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91396       };
91397     } catch (...) {
91398       {
91399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91400       };
91401     }
91402   }
91403
91404   jresult = (void *)result;
91405   return jresult;
91406 }
91407
91408
91409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91410   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91411
91412   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91413   {
91414     try {
91415       delete arg1;
91416     } catch (std::out_of_range& e) {
91417       {
91418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91419       };
91420     } catch (std::exception& e) {
91421       {
91422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91423       };
91424     } catch (Dali::DaliException e) {
91425       {
91426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91427       };
91428     } catch (...) {
91429       {
91430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91431       };
91432     }
91433   }
91434
91435 }
91436
91437
91438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91439   void * jresult ;
91440   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91441   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91442
91443   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91444   if (!arg1) {
91445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91446     return 0;
91447   }
91448   {
91449     try {
91450       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91451     } catch (std::out_of_range& e) {
91452       {
91453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91454       };
91455     } catch (std::exception& e) {
91456       {
91457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91458       };
91459     } catch (Dali::DaliException e) {
91460       {
91461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91462       };
91463     } catch (...) {
91464       {
91465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91466       };
91467     }
91468   }
91469
91470   jresult = (void *)result;
91471   return jresult;
91472 }
91473
91474
91475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91476   void * jresult ;
91477   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91478   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91479   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91480
91481   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91482   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91483   if (!arg2) {
91484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91485     return 0;
91486   }
91487   {
91488     try {
91489       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91490     } catch (std::out_of_range& e) {
91491       {
91492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91493       };
91494     } catch (std::exception& e) {
91495       {
91496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91497       };
91498     } catch (Dali::DaliException e) {
91499       {
91500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91501       };
91502     } catch (...) {
91503       {
91504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91505       };
91506     }
91507   }
91508
91509   jresult = (void *)result;
91510   return jresult;
91511 }
91512
91513
91514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91515   void * jresult ;
91516   Dali::Toolkit::AsyncImageLoader result;
91517
91518   {
91519     try {
91520       result = Dali::Toolkit::AsyncImageLoader::New();
91521     } catch (std::out_of_range& e) {
91522       {
91523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91524       };
91525     } catch (std::exception& e) {
91526       {
91527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91528       };
91529     } catch (Dali::DaliException e) {
91530       {
91531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91532       };
91533     } catch (...) {
91534       {
91535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91536       };
91537     }
91538   }
91539
91540   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91541   return jresult;
91542 }
91543
91544
91545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91546   void * jresult ;
91547   Dali::BaseHandle arg1 ;
91548   Dali::BaseHandle *argp1 ;
91549   Dali::Toolkit::AsyncImageLoader result;
91550
91551   argp1 = (Dali::BaseHandle *)jarg1;
91552   if (!argp1) {
91553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91554     return 0;
91555   }
91556   arg1 = *argp1;
91557   {
91558     try {
91559       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91560     } catch (std::out_of_range& e) {
91561       {
91562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91563       };
91564     } catch (std::exception& e) {
91565       {
91566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91567       };
91568     } catch (Dali::DaliException e) {
91569       {
91570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91571       };
91572     } catch (...) {
91573       {
91574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91575       };
91576     }
91577   }
91578
91579   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91580   return jresult;
91581 }
91582
91583
91584 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91585   unsigned int jresult ;
91586   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91587   std::string *arg2 = 0 ;
91588   uint32_t result;
91589
91590   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91591   if (!jarg2) {
91592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91593     return 0;
91594   }
91595   std::string arg2_str(jarg2);
91596   arg2 = &arg2_str;
91597   {
91598     try {
91599       result = (arg1)->Load((std::string const &)*arg2);
91600     } catch (std::out_of_range& e) {
91601       {
91602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91603       };
91604     } catch (std::exception& e) {
91605       {
91606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91607       };
91608     } catch (Dali::DaliException e) {
91609       {
91610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91611       };
91612     } catch (...) {
91613       {
91614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91615       };
91616     }
91617   }
91618
91619   jresult = result;
91620
91621   //argout typemap for const std::string&
91622
91623   return jresult;
91624 }
91625
91626
91627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91628   unsigned int jresult ;
91629   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91630   std::string *arg2 = 0 ;
91631   Dali::ImageDimensions arg3 ;
91632   Dali::ImageDimensions *argp3 ;
91633   uint32_t result;
91634
91635   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91636   if (!jarg2) {
91637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91638     return 0;
91639   }
91640   std::string arg2_str(jarg2);
91641   arg2 = &arg2_str;
91642   argp3 = (Dali::ImageDimensions *)jarg3;
91643   if (!argp3) {
91644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91645     return 0;
91646   }
91647   arg3 = *argp3;
91648   {
91649     try {
91650       result = (arg1)->Load((std::string const &)*arg2,arg3);
91651     } catch (std::out_of_range& e) {
91652       {
91653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91654       };
91655     } catch (std::exception& e) {
91656       {
91657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91658       };
91659     } catch (Dali::DaliException e) {
91660       {
91661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91662       };
91663     } catch (...) {
91664       {
91665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91666       };
91667     }
91668   }
91669
91670   jresult = result;
91671
91672   //argout typemap for const std::string&
91673
91674   return jresult;
91675 }
91676
91677
91678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
91679   unsigned int jresult ;
91680   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91681   std::string *arg2 = 0 ;
91682   Dali::ImageDimensions arg3 ;
91683   Dali::FittingMode::Type arg4 ;
91684   Dali::SamplingMode::Type arg5 ;
91685   bool arg6 ;
91686   Dali::ImageDimensions *argp3 ;
91687   uint32_t result;
91688
91689   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91690   if (!jarg2) {
91691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91692     return 0;
91693   }
91694   std::string arg2_str(jarg2);
91695   arg2 = &arg2_str;
91696   argp3 = (Dali::ImageDimensions *)jarg3;
91697   if (!argp3) {
91698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91699     return 0;
91700   }
91701   arg3 = *argp3;
91702   arg4 = (Dali::FittingMode::Type)jarg4;
91703   arg5 = (Dali::SamplingMode::Type)jarg5;
91704   arg6 = jarg6 ? true : false;
91705   {
91706     try {
91707       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
91708     } catch (std::out_of_range& e) {
91709       {
91710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91711       };
91712     } catch (std::exception& e) {
91713       {
91714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91715       };
91716     } catch (Dali::DaliException e) {
91717       {
91718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91719       };
91720     } catch (...) {
91721       {
91722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91723       };
91724     }
91725   }
91726
91727   jresult = result;
91728
91729   //argout typemap for const std::string&
91730
91731   return jresult;
91732 }
91733
91734
91735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91736   unsigned int jresult ;
91737   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91738   uint32_t arg2 ;
91739   bool result;
91740
91741   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91742   arg2 = (uint32_t)jarg2;
91743   {
91744     try {
91745       result = (bool)(arg1)->Cancel(arg2);
91746     } catch (std::out_of_range& e) {
91747       {
91748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91749       };
91750     } catch (std::exception& e) {
91751       {
91752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91753       };
91754     } catch (Dali::DaliException e) {
91755       {
91756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91757       };
91758     } catch (...) {
91759       {
91760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91761       };
91762     }
91763   }
91764
91765   jresult = result;
91766   return jresult;
91767 }
91768
91769
91770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91771   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91772
91773   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91774   {
91775     try {
91776       (arg1)->CancelAll();
91777     } catch (std::out_of_range& e) {
91778       {
91779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91780       };
91781     } catch (std::exception& e) {
91782       {
91783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91784       };
91785     } catch (Dali::DaliException e) {
91786       {
91787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91788       };
91789     } catch (...) {
91790       {
91791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91792       };
91793     }
91794   }
91795
91796 }
91797
91798
91799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91800   void * jresult ;
91801   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91802   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91803
91804   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91805   {
91806     try {
91807       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91808     } catch (std::out_of_range& e) {
91809       {
91810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91811       };
91812     } catch (std::exception& e) {
91813       {
91814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91815       };
91816     } catch (Dali::DaliException e) {
91817       {
91818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91819       };
91820     } catch (...) {
91821       {
91822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91823       };
91824     }
91825   }
91826
91827   jresult = (void *)result;
91828   return jresult;
91829 }
91830
91831
91832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91833   void * jresult ;
91834   std::string *arg1 = 0 ;
91835   Dali::PixelData result;
91836
91837   if (!jarg1) {
91838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91839     return 0;
91840   }
91841   std::string arg1_str(jarg1);
91842   arg1 = &arg1_str;
91843   {
91844     try {
91845       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
91846     } catch (std::out_of_range& e) {
91847       {
91848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91849       };
91850     } catch (std::exception& e) {
91851       {
91852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91853       };
91854     } catch (Dali::DaliException e) {
91855       {
91856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91857       };
91858     } catch (...) {
91859       {
91860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91861       };
91862     }
91863   }
91864
91865   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91866
91867   //argout typemap for const std::string&
91868
91869   return jresult;
91870 }
91871
91872
91873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91874   void * jresult ;
91875   std::string *arg1 = 0 ;
91876   Dali::ImageDimensions arg2 ;
91877   Dali::ImageDimensions *argp2 ;
91878   Dali::PixelData result;
91879
91880   if (!jarg1) {
91881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91882     return 0;
91883   }
91884   std::string arg1_str(jarg1);
91885   arg1 = &arg1_str;
91886   argp2 = (Dali::ImageDimensions *)jarg2;
91887   if (!argp2) {
91888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91889     return 0;
91890   }
91891   arg2 = *argp2;
91892   {
91893     try {
91894       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91895     } catch (std::out_of_range& e) {
91896       {
91897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91898       };
91899     } catch (std::exception& e) {
91900       {
91901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91902       };
91903     } catch (Dali::DaliException e) {
91904       {
91905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91906       };
91907     } catch (...) {
91908       {
91909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91910       };
91911     }
91912   }
91913
91914   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91915
91916   //argout typemap for const std::string&
91917
91918   return jresult;
91919 }
91920
91921
91922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91923   void * jresult ;
91924   std::string *arg1 = 0 ;
91925   Dali::ImageDimensions arg2 ;
91926   Dali::FittingMode::Type arg3 ;
91927   Dali::SamplingMode::Type arg4 ;
91928   bool arg5 ;
91929   Dali::ImageDimensions *argp2 ;
91930   Dali::PixelData result;
91931
91932   if (!jarg1) {
91933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91934     return 0;
91935   }
91936   std::string arg1_str(jarg1);
91937   arg1 = &arg1_str;
91938   argp2 = (Dali::ImageDimensions *)jarg2;
91939   if (!argp2) {
91940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91941     return 0;
91942   }
91943   arg2 = *argp2;
91944   arg3 = (Dali::FittingMode::Type)jarg3;
91945   arg4 = (Dali::SamplingMode::Type)jarg4;
91946   arg5 = jarg5 ? true : false;
91947   {
91948     try {
91949       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91950     } catch (std::out_of_range& e) {
91951       {
91952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91953       };
91954     } catch (std::exception& e) {
91955       {
91956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91957       };
91958     } catch (Dali::DaliException e) {
91959       {
91960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91961       };
91962     } catch (...) {
91963       {
91964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91965       };
91966     }
91967   }
91968
91969   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91970
91971   //argout typemap for const std::string&
91972
91973   return jresult;
91974 }
91975
91976
91977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91978   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91979
91980   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91981   {
91982     try {
91983       delete arg1;
91984     } catch (std::out_of_range& e) {
91985       {
91986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91987       };
91988     } catch (std::exception& e) {
91989       {
91990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91991       };
91992     } catch (Dali::DaliException e) {
91993       {
91994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91995       };
91996     } catch (...) {
91997       {
91998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91999       };
92000     }
92001   }
92002
92003 }
92004
92005
92006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
92007   void * jresult ;
92008   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
92009   Dali::Actor arg2 ;
92010   Dali::Actor arg3 ;
92011   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
92012   Dali::Actor *argp2 ;
92013   Dali::Actor *argp3 ;
92014   Dali::Actor result;
92015
92016   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
92017   argp2 = (Dali::Actor *)jarg2;
92018   if (!argp2) {
92019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92020     return 0;
92021   }
92022   arg2 = *argp2;
92023   argp3 = (Dali::Actor *)jarg3;
92024   if (!argp3) {
92025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
92026     return 0;
92027   }
92028   arg3 = *argp3;
92029   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
92030   {
92031     try {
92032       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
92033     } catch (std::out_of_range& e) {
92034       {
92035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92036       };
92037     } catch (std::exception& e) {
92038       {
92039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92040       };
92041     } catch (Dali::DaliException e) {
92042       {
92043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92044       };
92045     } catch (...) {
92046       {
92047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92048       };
92049     }
92050   }
92051
92052   jresult = new Dali::Actor((const Dali::Actor &)result);
92053   return jresult;
92054 }
92055
92056
92057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92058   void * jresult ;
92059   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92060
92061   {
92062     try {
92063       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92064     } catch (std::out_of_range& e) {
92065       {
92066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92067       };
92068     } catch (std::exception& e) {
92069       {
92070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92071       };
92072     } catch (Dali::DaliException e) {
92073       {
92074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92075       };
92076     } catch (...) {
92077       {
92078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92079       };
92080     }
92081   }
92082
92083   jresult = (void *)result;
92084   return jresult;
92085 }
92086
92087
92088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92089   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92090   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92091   if (director) {
92092     director->swig_connect_director(callback0);
92093   }
92094 }
92095
92096
92097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92098   KeyboardFocusManager arg1 ;
92099   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92100   KeyboardFocusManager *argp1 ;
92101
92102   argp1 = (KeyboardFocusManager *)jarg1;
92103   if (!argp1) {
92104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92105     return ;
92106   }
92107   arg1 = *argp1;
92108   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92109   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
92110   {
92111     try {
92112       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92113     } catch (std::out_of_range& e) {
92114       {
92115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92116       };
92117     } catch (std::exception& e) {
92118       {
92119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92120       };
92121     } catch (Dali::DaliException e) {
92122       {
92123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92124       };
92125     } catch (...) {
92126       {
92127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92128       };
92129     }
92130   }
92131
92132 }
92133
92134
92135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92136   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92137
92138   arg1 = (std::vector< unsigned int > *)jarg1;
92139   {
92140     try {
92141       (arg1)->clear();
92142     } catch (std::out_of_range& e) {
92143       {
92144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92145       };
92146     } catch (std::exception& e) {
92147       {
92148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92149       };
92150     } catch (Dali::DaliException e) {
92151       {
92152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92153       };
92154     } catch (...) {
92155       {
92156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92157       };
92158     }
92159   }
92160
92161 }
92162
92163
92164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92165   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92166   unsigned int *arg2 = 0 ;
92167   unsigned int temp2 ;
92168
92169   arg1 = (std::vector< unsigned int > *)jarg1;
92170   temp2 = (unsigned int)jarg2;
92171   arg2 = &temp2;
92172   {
92173     try {
92174       (arg1)->push_back((unsigned int const &)*arg2);
92175     } catch (std::out_of_range& e) {
92176       {
92177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92178       };
92179     } catch (std::exception& e) {
92180       {
92181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92182       };
92183     } catch (Dali::DaliException e) {
92184       {
92185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92186       };
92187     } catch (...) {
92188       {
92189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92190       };
92191     }
92192   }
92193
92194 }
92195
92196
92197 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92198   unsigned long jresult ;
92199   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92200   std::vector< unsigned int >::size_type result;
92201
92202   arg1 = (std::vector< unsigned int > *)jarg1;
92203   {
92204     try {
92205       result = ((std::vector< unsigned int > const *)arg1)->size();
92206     } catch (std::out_of_range& e) {
92207       {
92208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92209       };
92210     } catch (std::exception& e) {
92211       {
92212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92213       };
92214     } catch (Dali::DaliException e) {
92215       {
92216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92217       };
92218     } catch (...) {
92219       {
92220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92221       };
92222     }
92223   }
92224
92225   jresult = (unsigned long)result;
92226   return jresult;
92227 }
92228
92229
92230 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92231   unsigned long jresult ;
92232   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92233   std::vector< unsigned int >::size_type result;
92234
92235   arg1 = (std::vector< unsigned int > *)jarg1;
92236   {
92237     try {
92238       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92239     } catch (std::out_of_range& e) {
92240       {
92241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92242       };
92243     } catch (std::exception& e) {
92244       {
92245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92246       };
92247     } catch (Dali::DaliException e) {
92248       {
92249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92250       };
92251     } catch (...) {
92252       {
92253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92254       };
92255     }
92256   }
92257
92258   jresult = (unsigned long)result;
92259   return jresult;
92260 }
92261
92262
92263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92264   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92265   std::vector< unsigned int >::size_type arg2 ;
92266
92267   arg1 = (std::vector< unsigned int > *)jarg1;
92268   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92269   {
92270     try {
92271       (arg1)->reserve(arg2);
92272     } catch (std::out_of_range& e) {
92273       {
92274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92275       };
92276     } catch (std::exception& e) {
92277       {
92278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92279       };
92280     } catch (Dali::DaliException e) {
92281       {
92282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92283       };
92284     } catch (...) {
92285       {
92286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92287       };
92288     }
92289   }
92290
92291 }
92292
92293
92294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92295   void * jresult ;
92296   std::vector< unsigned int > *result = 0 ;
92297
92298   {
92299     try {
92300       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92301     } catch (std::out_of_range& e) {
92302       {
92303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92304       };
92305     } catch (std::exception& e) {
92306       {
92307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92308       };
92309     } catch (Dali::DaliException e) {
92310       {
92311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92312       };
92313     } catch (...) {
92314       {
92315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92316       };
92317     }
92318   }
92319
92320   jresult = (void *)result;
92321   return jresult;
92322 }
92323
92324
92325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92326   void * jresult ;
92327   std::vector< unsigned int > *arg1 = 0 ;
92328   std::vector< unsigned int > *result = 0 ;
92329
92330   arg1 = (std::vector< unsigned int > *)jarg1;
92331   if (!arg1) {
92332     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92333     return 0;
92334   }
92335   {
92336     try {
92337       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92338     } catch (std::out_of_range& e) {
92339       {
92340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92341       };
92342     } catch (std::exception& e) {
92343       {
92344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92345       };
92346     } catch (Dali::DaliException e) {
92347       {
92348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92349       };
92350     } catch (...) {
92351       {
92352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92353       };
92354     }
92355   }
92356
92357   jresult = (void *)result;
92358   return jresult;
92359 }
92360
92361
92362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92363   void * jresult ;
92364   int arg1 ;
92365   std::vector< unsigned int > *result = 0 ;
92366
92367   arg1 = (int)jarg1;
92368   {
92369     try {
92370       try {
92371         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92372       }
92373       catch(std::out_of_range &_e) {
92374         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92375         return 0;
92376       }
92377
92378     } catch (std::out_of_range& e) {
92379       {
92380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92381       };
92382     } catch (std::exception& e) {
92383       {
92384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92385       };
92386     } catch (Dali::DaliException e) {
92387       {
92388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92389       };
92390     } catch (...) {
92391       {
92392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92393       };
92394     }
92395   }
92396
92397   jresult = (void *)result;
92398   return jresult;
92399 }
92400
92401
92402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92403   unsigned int jresult ;
92404   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92405   int arg2 ;
92406   unsigned int result;
92407
92408   arg1 = (std::vector< unsigned int > *)jarg1;
92409   arg2 = (int)jarg2;
92410   {
92411     try {
92412       try {
92413         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92414       }
92415       catch(std::out_of_range &_e) {
92416         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92417         return 0;
92418       }
92419
92420     } catch (std::out_of_range& e) {
92421       {
92422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92423       };
92424     } catch (std::exception& e) {
92425       {
92426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92427       };
92428     } catch (Dali::DaliException e) {
92429       {
92430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92431       };
92432     } catch (...) {
92433       {
92434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92435       };
92436     }
92437   }
92438
92439   jresult = result;
92440   return jresult;
92441 }
92442
92443
92444 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92445   unsigned int jresult ;
92446   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92447   int arg2 ;
92448   unsigned int *result = 0 ;
92449
92450   arg1 = (std::vector< unsigned int > *)jarg1;
92451   arg2 = (int)jarg2;
92452   {
92453     try {
92454       try {
92455         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92456       }
92457       catch(std::out_of_range &_e) {
92458         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92459         return 0;
92460       }
92461
92462     } catch (std::out_of_range& e) {
92463       {
92464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92465       };
92466     } catch (std::exception& e) {
92467       {
92468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92469       };
92470     } catch (Dali::DaliException e) {
92471       {
92472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92473       };
92474     } catch (...) {
92475       {
92476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92477       };
92478     }
92479   }
92480
92481   jresult = *result;
92482   return jresult;
92483 }
92484
92485
92486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92487   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92488   int arg2 ;
92489   unsigned int *arg3 = 0 ;
92490   unsigned int temp3 ;
92491
92492   arg1 = (std::vector< unsigned int > *)jarg1;
92493   arg2 = (int)jarg2;
92494   temp3 = (unsigned int)jarg3;
92495   arg3 = &temp3;
92496   {
92497     try {
92498       try {
92499         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92500       }
92501       catch(std::out_of_range &_e) {
92502         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92503         return ;
92504       }
92505
92506     } catch (std::out_of_range& e) {
92507       {
92508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92509       };
92510     } catch (std::exception& e) {
92511       {
92512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92513       };
92514     } catch (Dali::DaliException e) {
92515       {
92516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92517       };
92518     } catch (...) {
92519       {
92520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92521       };
92522     }
92523   }
92524
92525 }
92526
92527
92528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92529   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92530   std::vector< unsigned int > *arg2 = 0 ;
92531
92532   arg1 = (std::vector< unsigned int > *)jarg1;
92533   arg2 = (std::vector< unsigned int > *)jarg2;
92534   if (!arg2) {
92535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92536     return ;
92537   }
92538   {
92539     try {
92540       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
92541     } catch (std::out_of_range& e) {
92542       {
92543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92544       };
92545     } catch (std::exception& e) {
92546       {
92547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92548       };
92549     } catch (Dali::DaliException e) {
92550       {
92551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92552       };
92553     } catch (...) {
92554       {
92555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92556       };
92557     }
92558   }
92559
92560 }
92561
92562
92563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92564   void * jresult ;
92565   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92566   int arg2 ;
92567   int arg3 ;
92568   std::vector< unsigned int > *result = 0 ;
92569
92570   arg1 = (std::vector< unsigned int > *)jarg1;
92571   arg2 = (int)jarg2;
92572   arg3 = (int)jarg3;
92573   {
92574     try {
92575       try {
92576         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92577       }
92578       catch(std::out_of_range &_e) {
92579         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92580         return 0;
92581       }
92582       catch(std::invalid_argument &_e) {
92583         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92584         return 0;
92585       }
92586
92587     } catch (std::out_of_range& e) {
92588       {
92589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92590       };
92591     } catch (std::exception& e) {
92592       {
92593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92594       };
92595     } catch (Dali::DaliException e) {
92596       {
92597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92598       };
92599     } catch (...) {
92600       {
92601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92602       };
92603     }
92604   }
92605
92606   jresult = (void *)result;
92607   return jresult;
92608 }
92609
92610
92611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92612   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92613   int arg2 ;
92614   unsigned int *arg3 = 0 ;
92615   unsigned int temp3 ;
92616
92617   arg1 = (std::vector< unsigned int > *)jarg1;
92618   arg2 = (int)jarg2;
92619   temp3 = (unsigned int)jarg3;
92620   arg3 = &temp3;
92621   {
92622     try {
92623       try {
92624         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92625       }
92626       catch(std::out_of_range &_e) {
92627         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92628         return ;
92629       }
92630
92631     } catch (std::out_of_range& e) {
92632       {
92633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92634       };
92635     } catch (std::exception& e) {
92636       {
92637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92638       };
92639     } catch (Dali::DaliException e) {
92640       {
92641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92642       };
92643     } catch (...) {
92644       {
92645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92646       };
92647     }
92648   }
92649
92650 }
92651
92652
92653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92654   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92655   int arg2 ;
92656   std::vector< unsigned int > *arg3 = 0 ;
92657
92658   arg1 = (std::vector< unsigned int > *)jarg1;
92659   arg2 = (int)jarg2;
92660   arg3 = (std::vector< unsigned int > *)jarg3;
92661   if (!arg3) {
92662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92663     return ;
92664   }
92665   {
92666     try {
92667       try {
92668         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92669       }
92670       catch(std::out_of_range &_e) {
92671         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92672         return ;
92673       }
92674
92675     } catch (std::out_of_range& e) {
92676       {
92677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92678       };
92679     } catch (std::exception& e) {
92680       {
92681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92682       };
92683     } catch (Dali::DaliException e) {
92684       {
92685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92686       };
92687     } catch (...) {
92688       {
92689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92690       };
92691     }
92692   }
92693
92694 }
92695
92696
92697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
92698   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92699   int arg2 ;
92700
92701   arg1 = (std::vector< unsigned int > *)jarg1;
92702   arg2 = (int)jarg2;
92703   {
92704     try {
92705       try {
92706         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
92707       }
92708       catch(std::out_of_range &_e) {
92709         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92710         return ;
92711       }
92712
92713     } catch (std::out_of_range& e) {
92714       {
92715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92716       };
92717     } catch (std::exception& e) {
92718       {
92719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92720       };
92721     } catch (Dali::DaliException e) {
92722       {
92723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92724       };
92725     } catch (...) {
92726       {
92727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92728       };
92729     }
92730   }
92731
92732 }
92733
92734
92735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92736   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92737   int arg2 ;
92738   int arg3 ;
92739
92740   arg1 = (std::vector< unsigned int > *)jarg1;
92741   arg2 = (int)jarg2;
92742   arg3 = (int)jarg3;
92743   {
92744     try {
92745       try {
92746         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92747       }
92748       catch(std::out_of_range &_e) {
92749         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92750         return ;
92751       }
92752       catch(std::invalid_argument &_e) {
92753         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92754         return ;
92755       }
92756
92757     } catch (std::out_of_range& e) {
92758       {
92759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92760       };
92761     } catch (std::exception& e) {
92762       {
92763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92764       };
92765     } catch (Dali::DaliException e) {
92766       {
92767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92768       };
92769     } catch (...) {
92770       {
92771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92772       };
92773     }
92774   }
92775
92776 }
92777
92778
92779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92780   void * jresult ;
92781   unsigned int *arg1 = 0 ;
92782   int arg2 ;
92783   unsigned int temp1 ;
92784   std::vector< unsigned int > *result = 0 ;
92785
92786   temp1 = (unsigned int)jarg1;
92787   arg1 = &temp1;
92788   arg2 = (int)jarg2;
92789   {
92790     try {
92791       try {
92792         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92793       }
92794       catch(std::out_of_range &_e) {
92795         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92796         return 0;
92797       }
92798
92799     } catch (std::out_of_range& e) {
92800       {
92801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92802       };
92803     } catch (std::exception& e) {
92804       {
92805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92806       };
92807     } catch (Dali::DaliException e) {
92808       {
92809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92810       };
92811     } catch (...) {
92812       {
92813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92814       };
92815     }
92816   }
92817
92818   jresult = (void *)result;
92819   return jresult;
92820 }
92821
92822
92823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92824   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92825
92826   arg1 = (std::vector< unsigned int > *)jarg1;
92827   {
92828     try {
92829       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92830     } catch (std::out_of_range& e) {
92831       {
92832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92833       };
92834     } catch (std::exception& e) {
92835       {
92836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92837       };
92838     } catch (Dali::DaliException e) {
92839       {
92840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92841       };
92842     } catch (...) {
92843       {
92844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92845       };
92846     }
92847   }
92848
92849 }
92850
92851
92852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92853   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92854   int arg2 ;
92855   int arg3 ;
92856
92857   arg1 = (std::vector< unsigned int > *)jarg1;
92858   arg2 = (int)jarg2;
92859   arg3 = (int)jarg3;
92860   {
92861     try {
92862       try {
92863         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92864       }
92865       catch(std::out_of_range &_e) {
92866         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92867         return ;
92868       }
92869       catch(std::invalid_argument &_e) {
92870         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92871         return ;
92872       }
92873
92874     } catch (std::out_of_range& e) {
92875       {
92876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92877       };
92878     } catch (std::exception& e) {
92879       {
92880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92881       };
92882     } catch (Dali::DaliException e) {
92883       {
92884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92885       };
92886     } catch (...) {
92887       {
92888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92889       };
92890     }
92891   }
92892
92893 }
92894
92895
92896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92897   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92898   int arg2 ;
92899   std::vector< unsigned int > *arg3 = 0 ;
92900
92901   arg1 = (std::vector< unsigned int > *)jarg1;
92902   arg2 = (int)jarg2;
92903   arg3 = (std::vector< unsigned int > *)jarg3;
92904   if (!arg3) {
92905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92906     return ;
92907   }
92908   {
92909     try {
92910       try {
92911         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92912       }
92913       catch(std::out_of_range &_e) {
92914         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92915         return ;
92916       }
92917
92918     } catch (std::out_of_range& e) {
92919       {
92920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92921       };
92922     } catch (std::exception& e) {
92923       {
92924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92925       };
92926     } catch (Dali::DaliException e) {
92927       {
92928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92929       };
92930     } catch (...) {
92931       {
92932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92933       };
92934     }
92935   }
92936
92937 }
92938
92939
92940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92941   unsigned int jresult ;
92942   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92943   unsigned int *arg2 = 0 ;
92944   unsigned int temp2 ;
92945   bool result;
92946
92947   arg1 = (std::vector< unsigned int > *)jarg1;
92948   temp2 = (unsigned int)jarg2;
92949   arg2 = &temp2;
92950   {
92951     try {
92952       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92953     } catch (std::out_of_range& e) {
92954       {
92955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92956       };
92957     } catch (std::exception& e) {
92958       {
92959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92960       };
92961     } catch (Dali::DaliException e) {
92962       {
92963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92964       };
92965     } catch (...) {
92966       {
92967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92968       };
92969     }
92970   }
92971
92972   jresult = result;
92973   return jresult;
92974 }
92975
92976
92977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92978   int jresult ;
92979   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92980   unsigned int *arg2 = 0 ;
92981   unsigned int temp2 ;
92982   int result;
92983
92984   arg1 = (std::vector< unsigned int > *)jarg1;
92985   temp2 = (unsigned int)jarg2;
92986   arg2 = &temp2;
92987   {
92988     try {
92989       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92990     } catch (std::out_of_range& e) {
92991       {
92992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92993       };
92994     } catch (std::exception& e) {
92995       {
92996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92997       };
92998     } catch (Dali::DaliException e) {
92999       {
93000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93001       };
93002     } catch (...) {
93003       {
93004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93005       };
93006     }
93007   }
93008
93009   jresult = result;
93010   return jresult;
93011 }
93012
93013
93014 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
93015   int jresult ;
93016   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93017   unsigned int *arg2 = 0 ;
93018   unsigned int temp2 ;
93019   int result;
93020
93021   arg1 = (std::vector< unsigned int > *)jarg1;
93022   temp2 = (unsigned int)jarg2;
93023   arg2 = &temp2;
93024   {
93025     try {
93026       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
93027     } catch (std::out_of_range& e) {
93028       {
93029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93030       };
93031     } catch (std::exception& e) {
93032       {
93033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93034       };
93035     } catch (Dali::DaliException e) {
93036       {
93037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93038       };
93039     } catch (...) {
93040       {
93041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93042       };
93043     }
93044   }
93045
93046   jresult = result;
93047   return jresult;
93048 }
93049
93050
93051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93052   unsigned int jresult ;
93053   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93054   unsigned int *arg2 = 0 ;
93055   unsigned int temp2 ;
93056   bool result;
93057
93058   arg1 = (std::vector< unsigned int > *)jarg1;
93059   temp2 = (unsigned int)jarg2;
93060   arg2 = &temp2;
93061   {
93062     try {
93063       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93064     } catch (std::out_of_range& e) {
93065       {
93066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93067       };
93068     } catch (std::exception& e) {
93069       {
93070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93071       };
93072     } catch (Dali::DaliException e) {
93073       {
93074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93075       };
93076     } catch (...) {
93077       {
93078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93079       };
93080     }
93081   }
93082
93083   jresult = result;
93084   return jresult;
93085 }
93086
93087
93088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93089   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93090
93091   arg1 = (std::vector< unsigned int > *)jarg1;
93092   {
93093     try {
93094       delete arg1;
93095     } catch (std::out_of_range& e) {
93096       {
93097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93098       };
93099     } catch (std::exception& e) {
93100       {
93101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93102       };
93103     } catch (Dali::DaliException e) {
93104       {
93105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93106       };
93107     } catch (...) {
93108       {
93109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93110       };
93111     }
93112   }
93113
93114 }
93115
93116
93117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93118   void * jresult ;
93119   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93120
93121   {
93122     try {
93123       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93124     } catch (std::out_of_range& e) {
93125       {
93126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93127       };
93128     } catch (std::exception& e) {
93129       {
93130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93131       };
93132     } catch (Dali::DaliException e) {
93133       {
93134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93135       };
93136     } catch (...) {
93137       {
93138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93139       };
93140     }
93141   }
93142
93143   jresult = (void *)result;
93144   return jresult;
93145 }
93146
93147
93148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93149   void * jresult ;
93150   unsigned int arg1 ;
93151   Dali::Actor arg2 ;
93152   Dali::Actor *argp2 ;
93153   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93154
93155   arg1 = (unsigned int)jarg1;
93156   argp2 = (Dali::Actor *)jarg2;
93157   if (!argp2) {
93158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93159     return 0;
93160   }
93161   arg2 = *argp2;
93162   {
93163     try {
93164       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93165     } catch (std::out_of_range& e) {
93166       {
93167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93168       };
93169     } catch (std::exception& e) {
93170       {
93171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93172       };
93173     } catch (Dali::DaliException e) {
93174       {
93175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93176       };
93177     } catch (...) {
93178       {
93179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93180       };
93181     }
93182   }
93183
93184   jresult = (void *)result;
93185   return jresult;
93186 }
93187
93188
93189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93190   void * jresult ;
93191   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93192   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93193
93194   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93195   if (!arg1) {
93196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93197     return 0;
93198   }
93199   {
93200     try {
93201       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93202     } catch (std::out_of_range& e) {
93203       {
93204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93205       };
93206     } catch (std::exception& e) {
93207       {
93208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93209       };
93210     } catch (Dali::DaliException e) {
93211       {
93212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93213       };
93214     } catch (...) {
93215       {
93216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93217       };
93218     }
93219   }
93220
93221   jresult = (void *)result;
93222   return jresult;
93223 }
93224
93225
93226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93227   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93228   unsigned int arg2 ;
93229
93230   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93231   arg2 = (unsigned int)jarg2;
93232   if (arg1) (arg1)->first = arg2;
93233 }
93234
93235
93236 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93237   unsigned int jresult ;
93238   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93239   unsigned int result;
93240
93241   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93242   result = (unsigned int) ((arg1)->first);
93243   jresult = result;
93244   return jresult;
93245 }
93246
93247
93248 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93249   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93250   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93251
93252   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93253   arg2 = (Dali::Actor *)jarg2;
93254   if (arg1) (arg1)->second = *arg2;
93255 }
93256
93257
93258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93259   void * jresult ;
93260   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93261   Dali::Actor *result = 0 ;
93262
93263   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93264   result = (Dali::Actor *)& ((arg1)->second);
93265   jresult = (void *)result;
93266   return jresult;
93267 }
93268
93269
93270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93271   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93272
93273   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93274   {
93275     try {
93276       delete arg1;
93277     } catch (std::out_of_range& e) {
93278       {
93279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93280       };
93281     } catch (std::exception& e) {
93282       {
93283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93284       };
93285     } catch (Dali::DaliException e) {
93286       {
93287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93288       };
93289     } catch (...) {
93290       {
93291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93292       };
93293     }
93294   }
93295
93296 }
93297
93298
93299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93300   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93301
93302   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93303   {
93304     try {
93305       (arg1)->clear();
93306     } catch (std::out_of_range& e) {
93307       {
93308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93309       };
93310     } catch (std::exception& e) {
93311       {
93312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93313       };
93314     } catch (Dali::DaliException e) {
93315       {
93316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93317       };
93318     } catch (...) {
93319       {
93320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93321       };
93322     }
93323   }
93324
93325 }
93326
93327
93328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93329   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93330   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93331
93332   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93333   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93334   if (!arg2) {
93335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93336     return ;
93337   }
93338   {
93339     try {
93340       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
93341     } catch (std::out_of_range& e) {
93342       {
93343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93344       };
93345     } catch (std::exception& e) {
93346       {
93347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93348       };
93349     } catch (Dali::DaliException e) {
93350       {
93351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93352       };
93353     } catch (...) {
93354       {
93355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93356       };
93357     }
93358   }
93359
93360 }
93361
93362
93363 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93364   unsigned long jresult ;
93365   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93366   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93367
93368   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93369   {
93370     try {
93371       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93372     } catch (std::out_of_range& e) {
93373       {
93374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93375       };
93376     } catch (std::exception& e) {
93377       {
93378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93379       };
93380     } catch (Dali::DaliException e) {
93381       {
93382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93383       };
93384     } catch (...) {
93385       {
93386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93387       };
93388     }
93389   }
93390
93391   jresult = (unsigned long)result;
93392   return jresult;
93393 }
93394
93395
93396 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93397   unsigned long jresult ;
93398   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93399   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93400
93401   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93402   {
93403     try {
93404       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93405     } catch (std::out_of_range& e) {
93406       {
93407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93408       };
93409     } catch (std::exception& e) {
93410       {
93411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93412       };
93413     } catch (Dali::DaliException e) {
93414       {
93415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93416       };
93417     } catch (...) {
93418       {
93419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93420       };
93421     }
93422   }
93423
93424   jresult = (unsigned long)result;
93425   return jresult;
93426 }
93427
93428
93429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93430   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93431   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93432
93433   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93434   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93435   {
93436     try {
93437       (arg1)->reserve(arg2);
93438     } catch (std::out_of_range& e) {
93439       {
93440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93441       };
93442     } catch (std::exception& e) {
93443       {
93444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93445       };
93446     } catch (Dali::DaliException e) {
93447       {
93448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93449       };
93450     } catch (...) {
93451       {
93452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93453       };
93454     }
93455   }
93456
93457 }
93458
93459
93460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93461   void * jresult ;
93462   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93463
93464   {
93465     try {
93466       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93467     } catch (std::out_of_range& e) {
93468       {
93469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93470       };
93471     } catch (std::exception& e) {
93472       {
93473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93474       };
93475     } catch (Dali::DaliException e) {
93476       {
93477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93478       };
93479     } catch (...) {
93480       {
93481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93482       };
93483     }
93484   }
93485
93486   jresult = (void *)result;
93487   return jresult;
93488 }
93489
93490
93491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93492   void * jresult ;
93493   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93494   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93495
93496   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93497   if (!arg1) {
93498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93499     return 0;
93500   }
93501   {
93502     try {
93503       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);
93504     } catch (std::out_of_range& e) {
93505       {
93506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93507       };
93508     } catch (std::exception& e) {
93509       {
93510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93511       };
93512     } catch (Dali::DaliException e) {
93513       {
93514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93515       };
93516     } catch (...) {
93517       {
93518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93519       };
93520     }
93521   }
93522
93523   jresult = (void *)result;
93524   return jresult;
93525 }
93526
93527
93528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93529   void * jresult ;
93530   int arg1 ;
93531   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93532
93533   arg1 = (int)jarg1;
93534   {
93535     try {
93536       try {
93537         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);
93538       }
93539       catch(std::out_of_range &_e) {
93540         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93541         return 0;
93542       }
93543
93544     } catch (std::out_of_range& e) {
93545       {
93546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93547       };
93548     } catch (std::exception& e) {
93549       {
93550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93551       };
93552     } catch (Dali::DaliException e) {
93553       {
93554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93555       };
93556     } catch (...) {
93557       {
93558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93559       };
93560     }
93561   }
93562
93563   jresult = (void *)result;
93564   return jresult;
93565 }
93566
93567
93568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93569   void * jresult ;
93570   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93571   int arg2 ;
93572   std::pair< unsigned int,Dali::Actor > result;
93573
93574   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93575   arg2 = (int)jarg2;
93576   {
93577     try {
93578       try {
93579         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93580       }
93581       catch(std::out_of_range &_e) {
93582         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93583         return 0;
93584       }
93585
93586     } catch (std::out_of_range& e) {
93587       {
93588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93589       };
93590     } catch (std::exception& e) {
93591       {
93592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93593       };
93594     } catch (Dali::DaliException e) {
93595       {
93596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93597       };
93598     } catch (...) {
93599       {
93600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93601       };
93602     }
93603   }
93604
93605   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93606   return jresult;
93607 }
93608
93609
93610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93611   void * jresult ;
93612   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93613   int arg2 ;
93614   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93615
93616   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93617   arg2 = (int)jarg2;
93618   {
93619     try {
93620       try {
93621         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93622       }
93623       catch(std::out_of_range &_e) {
93624         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93625         return 0;
93626       }
93627
93628     } catch (std::out_of_range& e) {
93629       {
93630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93631       };
93632     } catch (std::exception& e) {
93633       {
93634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93635       };
93636     } catch (Dali::DaliException e) {
93637       {
93638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93639       };
93640     } catch (...) {
93641       {
93642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93643       };
93644     }
93645   }
93646
93647   jresult = (void *)result;
93648   return jresult;
93649 }
93650
93651
93652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93653   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93654   int arg2 ;
93655   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93656
93657   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93658   arg2 = (int)jarg2;
93659   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93660   if (!arg3) {
93661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93662     return ;
93663   }
93664   {
93665     try {
93666       try {
93667         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);
93668       }
93669       catch(std::out_of_range &_e) {
93670         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93671         return ;
93672       }
93673
93674     } catch (std::out_of_range& e) {
93675       {
93676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93677       };
93678     } catch (std::exception& e) {
93679       {
93680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93681       };
93682     } catch (Dali::DaliException e) {
93683       {
93684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93685       };
93686     } catch (...) {
93687       {
93688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93689       };
93690     }
93691   }
93692
93693 }
93694
93695
93696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
93697   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93698   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
93699
93700   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93701   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
93702   if (!arg2) {
93703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93704     return ;
93705   }
93706   {
93707     try {
93708       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);
93709     } catch (std::out_of_range& e) {
93710       {
93711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93712       };
93713     } catch (std::exception& e) {
93714       {
93715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93716       };
93717     } catch (Dali::DaliException e) {
93718       {
93719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93720       };
93721     } catch (...) {
93722       {
93723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93724       };
93725     }
93726   }
93727
93728 }
93729
93730
93731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
93732   void * jresult ;
93733   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93734   int arg2 ;
93735   int arg3 ;
93736   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93737
93738   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93739   arg2 = (int)jarg2;
93740   arg3 = (int)jarg3;
93741   {
93742     try {
93743       try {
93744         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);
93745       }
93746       catch(std::out_of_range &_e) {
93747         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93748         return 0;
93749       }
93750       catch(std::invalid_argument &_e) {
93751         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93752         return 0;
93753       }
93754
93755     } catch (std::out_of_range& e) {
93756       {
93757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93758       };
93759     } catch (std::exception& e) {
93760       {
93761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93762       };
93763     } catch (Dali::DaliException e) {
93764       {
93765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93766       };
93767     } catch (...) {
93768       {
93769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93770       };
93771     }
93772   }
93773
93774   jresult = (void *)result;
93775   return jresult;
93776 }
93777
93778
93779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93780   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93781   int arg2 ;
93782   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93783
93784   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93785   arg2 = (int)jarg2;
93786   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93787   if (!arg3) {
93788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93789     return ;
93790   }
93791   {
93792     try {
93793       try {
93794         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);
93795       }
93796       catch(std::out_of_range &_e) {
93797         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93798         return ;
93799       }
93800
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_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93824   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93825   int arg2 ;
93826   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93827
93828   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93829   arg2 = (int)jarg2;
93830   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93831   if (!arg3) {
93832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93833     return ;
93834   }
93835   {
93836     try {
93837       try {
93838         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);
93839       }
93840       catch(std::out_of_range &_e) {
93841         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93842         return ;
93843       }
93844
93845     } catch (std::out_of_range& e) {
93846       {
93847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93848       };
93849     } catch (std::exception& e) {
93850       {
93851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93852       };
93853     } catch (Dali::DaliException e) {
93854       {
93855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93856       };
93857     } catch (...) {
93858       {
93859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93860       };
93861     }
93862   }
93863
93864 }
93865
93866
93867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93868   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93869   int arg2 ;
93870
93871   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93872   arg2 = (int)jarg2;
93873   {
93874     try {
93875       try {
93876         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93877       }
93878       catch(std::out_of_range &_e) {
93879         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93880         return ;
93881       }
93882
93883     } catch (std::out_of_range& e) {
93884       {
93885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93886       };
93887     } catch (std::exception& e) {
93888       {
93889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93890       };
93891     } catch (Dali::DaliException e) {
93892       {
93893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93894       };
93895     } catch (...) {
93896       {
93897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93898       };
93899     }
93900   }
93901
93902 }
93903
93904
93905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93906   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93907   int arg2 ;
93908   int arg3 ;
93909
93910   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93911   arg2 = (int)jarg2;
93912   arg3 = (int)jarg3;
93913   {
93914     try {
93915       try {
93916         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93917       }
93918       catch(std::out_of_range &_e) {
93919         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93920         return ;
93921       }
93922       catch(std::invalid_argument &_e) {
93923         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93924         return ;
93925       }
93926
93927     } catch (std::out_of_range& e) {
93928       {
93929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93930       };
93931     } catch (std::exception& e) {
93932       {
93933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93934       };
93935     } catch (Dali::DaliException e) {
93936       {
93937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93938       };
93939     } catch (...) {
93940       {
93941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93942       };
93943     }
93944   }
93945
93946 }
93947
93948
93949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93950   void * jresult ;
93951   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93952   int arg2 ;
93953   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93954
93955   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93956   if (!arg1) {
93957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93958     return 0;
93959   }
93960   arg2 = (int)jarg2;
93961   {
93962     try {
93963       try {
93964         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);
93965       }
93966       catch(std::out_of_range &_e) {
93967         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93968         return 0;
93969       }
93970
93971     } catch (std::out_of_range& e) {
93972       {
93973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93974       };
93975     } catch (std::exception& e) {
93976       {
93977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93978       };
93979     } catch (Dali::DaliException e) {
93980       {
93981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93982       };
93983     } catch (...) {
93984       {
93985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93986       };
93987     }
93988   }
93989
93990   jresult = (void *)result;
93991   return jresult;
93992 }
93993
93994
93995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93996   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93997
93998   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93999   {
94000     try {
94001       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
94002     } catch (std::out_of_range& e) {
94003       {
94004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94005       };
94006     } catch (std::exception& e) {
94007       {
94008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94009       };
94010     } catch (Dali::DaliException e) {
94011       {
94012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94013       };
94014     } catch (...) {
94015       {
94016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94017       };
94018     }
94019   }
94020
94021 }
94022
94023
94024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94025   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94026   int arg2 ;
94027   int arg3 ;
94028
94029   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94030   arg2 = (int)jarg2;
94031   arg3 = (int)jarg3;
94032   {
94033     try {
94034       try {
94035         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94036       }
94037       catch(std::out_of_range &_e) {
94038         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94039         return ;
94040       }
94041       catch(std::invalid_argument &_e) {
94042         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94043         return ;
94044       }
94045
94046     } catch (std::out_of_range& e) {
94047       {
94048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94049       };
94050     } catch (std::exception& e) {
94051       {
94052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94053       };
94054     } catch (Dali::DaliException e) {
94055       {
94056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94057       };
94058     } catch (...) {
94059       {
94060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94061       };
94062     }
94063   }
94064
94065 }
94066
94067
94068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94069   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94070   int arg2 ;
94071   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94072
94073   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94074   arg2 = (int)jarg2;
94075   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94076   if (!arg3) {
94077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94078     return ;
94079   }
94080   {
94081     try {
94082       try {
94083         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);
94084       }
94085       catch(std::out_of_range &_e) {
94086         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94087         return ;
94088       }
94089
94090     } catch (std::out_of_range& e) {
94091       {
94092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94093       };
94094     } catch (std::exception& e) {
94095       {
94096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94097       };
94098     } catch (Dali::DaliException e) {
94099       {
94100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94101       };
94102     } catch (...) {
94103       {
94104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94105       };
94106     }
94107   }
94108
94109 }
94110
94111
94112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94113   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94114
94115   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94116   {
94117     try {
94118       delete arg1;
94119     } catch (std::out_of_range& e) {
94120       {
94121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94122       };
94123     } catch (std::exception& e) {
94124       {
94125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94126       };
94127     } catch (Dali::DaliException e) {
94128       {
94129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94130       };
94131     } catch (...) {
94132       {
94133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94134       };
94135     }
94136   }
94137
94138 }
94139
94140
94141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94142   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94143
94144   arg1 = (std::vector< Dali::Actor > *)jarg1;
94145   {
94146     try {
94147       (arg1)->clear();
94148     } catch (std::out_of_range& e) {
94149       {
94150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94151       };
94152     } catch (std::exception& e) {
94153       {
94154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94155       };
94156     } catch (Dali::DaliException e) {
94157       {
94158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94159       };
94160     } catch (...) {
94161       {
94162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94163       };
94164     }
94165   }
94166
94167 }
94168
94169
94170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94171   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94172   Dali::Actor *arg2 = 0 ;
94173
94174   arg1 = (std::vector< Dali::Actor > *)jarg1;
94175   arg2 = (Dali::Actor *)jarg2;
94176   if (!arg2) {
94177     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94178     return ;
94179   }
94180   {
94181     try {
94182       (arg1)->push_back((Dali::Actor const &)*arg2);
94183     } catch (std::out_of_range& e) {
94184       {
94185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94186       };
94187     } catch (std::exception& e) {
94188       {
94189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94190       };
94191     } catch (Dali::DaliException e) {
94192       {
94193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94194       };
94195     } catch (...) {
94196       {
94197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94198       };
94199     }
94200   }
94201
94202 }
94203
94204
94205 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94206   unsigned long jresult ;
94207   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94208   std::vector< Dali::Actor >::size_type result;
94209
94210   arg1 = (std::vector< Dali::Actor > *)jarg1;
94211   {
94212     try {
94213       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94214     } catch (std::out_of_range& e) {
94215       {
94216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94217       };
94218     } catch (std::exception& e) {
94219       {
94220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94221       };
94222     } catch (Dali::DaliException e) {
94223       {
94224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94225       };
94226     } catch (...) {
94227       {
94228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94229       };
94230     }
94231   }
94232
94233   jresult = (unsigned long)result;
94234   return jresult;
94235 }
94236
94237
94238 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94239   unsigned long jresult ;
94240   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94241   std::vector< Dali::Actor >::size_type result;
94242
94243   arg1 = (std::vector< Dali::Actor > *)jarg1;
94244   {
94245     try {
94246       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94247     } catch (std::out_of_range& e) {
94248       {
94249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94250       };
94251     } catch (std::exception& e) {
94252       {
94253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94254       };
94255     } catch (Dali::DaliException e) {
94256       {
94257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94258       };
94259     } catch (...) {
94260       {
94261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94262       };
94263     }
94264   }
94265
94266   jresult = (unsigned long)result;
94267   return jresult;
94268 }
94269
94270
94271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94272   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94273   std::vector< Dali::Actor >::size_type arg2 ;
94274
94275   arg1 = (std::vector< Dali::Actor > *)jarg1;
94276   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94277   {
94278     try {
94279       (arg1)->reserve(arg2);
94280     } catch (std::out_of_range& e) {
94281       {
94282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94283       };
94284     } catch (std::exception& e) {
94285       {
94286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94287       };
94288     } catch (Dali::DaliException e) {
94289       {
94290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94291       };
94292     } catch (...) {
94293       {
94294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94295       };
94296     }
94297   }
94298
94299 }
94300
94301
94302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94303   void * jresult ;
94304   std::vector< Dali::Actor > *result = 0 ;
94305
94306   {
94307     try {
94308       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94309     } catch (std::out_of_range& e) {
94310       {
94311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94312       };
94313     } catch (std::exception& e) {
94314       {
94315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94316       };
94317     } catch (Dali::DaliException e) {
94318       {
94319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94320       };
94321     } catch (...) {
94322       {
94323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94324       };
94325     }
94326   }
94327
94328   jresult = (void *)result;
94329   return jresult;
94330 }
94331
94332
94333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94334   void * jresult ;
94335   std::vector< Dali::Actor > *arg1 = 0 ;
94336   std::vector< Dali::Actor > *result = 0 ;
94337
94338   arg1 = (std::vector< Dali::Actor > *)jarg1;
94339   if (!arg1) {
94340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94341     return 0;
94342   }
94343   {
94344     try {
94345       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94346     } catch (std::out_of_range& e) {
94347       {
94348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94349       };
94350     } catch (std::exception& e) {
94351       {
94352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94353       };
94354     } catch (Dali::DaliException e) {
94355       {
94356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94357       };
94358     } catch (...) {
94359       {
94360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94361       };
94362     }
94363   }
94364
94365   jresult = (void *)result;
94366   return jresult;
94367 }
94368
94369
94370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94371   void * jresult ;
94372   int arg1 ;
94373   std::vector< Dali::Actor > *result = 0 ;
94374
94375   arg1 = (int)jarg1;
94376   {
94377     try {
94378       try {
94379         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94380       }
94381       catch(std::out_of_range &_e) {
94382         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94383         return 0;
94384       }
94385
94386     } catch (std::out_of_range& e) {
94387       {
94388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94389       };
94390     } catch (std::exception& e) {
94391       {
94392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94393       };
94394     } catch (Dali::DaliException e) {
94395       {
94396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94397       };
94398     } catch (...) {
94399       {
94400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94401       };
94402     }
94403   }
94404
94405   jresult = (void *)result;
94406   return jresult;
94407 }
94408
94409
94410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94411   void * jresult ;
94412   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94413   int arg2 ;
94414   Dali::Actor result;
94415
94416   arg1 = (std::vector< Dali::Actor > *)jarg1;
94417   arg2 = (int)jarg2;
94418   {
94419     try {
94420       try {
94421         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94422       }
94423       catch(std::out_of_range &_e) {
94424         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94425         return 0;
94426       }
94427
94428     } catch (std::out_of_range& e) {
94429       {
94430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94431       };
94432     } catch (std::exception& e) {
94433       {
94434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94435       };
94436     } catch (Dali::DaliException e) {
94437       {
94438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94439       };
94440     } catch (...) {
94441       {
94442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94443       };
94444     }
94445   }
94446
94447   jresult = new Dali::Actor((const Dali::Actor &)result);
94448   return jresult;
94449 }
94450
94451
94452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94453   void * jresult ;
94454   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94455   int arg2 ;
94456   Dali::Actor *result = 0 ;
94457
94458   arg1 = (std::vector< Dali::Actor > *)jarg1;
94459   arg2 = (int)jarg2;
94460   {
94461     try {
94462       try {
94463         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94464       }
94465       catch(std::out_of_range &_e) {
94466         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94467         return 0;
94468       }
94469
94470     } catch (std::out_of_range& e) {
94471       {
94472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94473       };
94474     } catch (std::exception& e) {
94475       {
94476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94477       };
94478     } catch (Dali::DaliException e) {
94479       {
94480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94481       };
94482     } catch (...) {
94483       {
94484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94485       };
94486     }
94487   }
94488
94489   jresult = (void *)result;
94490   return jresult;
94491 }
94492
94493
94494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94495   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94496   int arg2 ;
94497   Dali::Actor *arg3 = 0 ;
94498
94499   arg1 = (std::vector< Dali::Actor > *)jarg1;
94500   arg2 = (int)jarg2;
94501   arg3 = (Dali::Actor *)jarg3;
94502   if (!arg3) {
94503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94504     return ;
94505   }
94506   {
94507     try {
94508       try {
94509         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94510       }
94511       catch(std::out_of_range &_e) {
94512         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94513         return ;
94514       }
94515
94516     } catch (std::out_of_range& e) {
94517       {
94518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94519       };
94520     } catch (std::exception& e) {
94521       {
94522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94523       };
94524     } catch (Dali::DaliException e) {
94525       {
94526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94527       };
94528     } catch (...) {
94529       {
94530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94531       };
94532     }
94533   }
94534
94535 }
94536
94537
94538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94539   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94540   std::vector< Dali::Actor > *arg2 = 0 ;
94541
94542   arg1 = (std::vector< Dali::Actor > *)jarg1;
94543   arg2 = (std::vector< Dali::Actor > *)jarg2;
94544   if (!arg2) {
94545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94546     return ;
94547   }
94548   {
94549     try {
94550       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
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_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
94574   void * jresult ;
94575   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94576   int arg2 ;
94577   int arg3 ;
94578   std::vector< Dali::Actor > *result = 0 ;
94579
94580   arg1 = (std::vector< Dali::Actor > *)jarg1;
94581   arg2 = (int)jarg2;
94582   arg3 = (int)jarg3;
94583   {
94584     try {
94585       try {
94586         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94587       }
94588       catch(std::out_of_range &_e) {
94589         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94590         return 0;
94591       }
94592       catch(std::invalid_argument &_e) {
94593         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94594         return 0;
94595       }
94596
94597     } catch (std::out_of_range& e) {
94598       {
94599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94600       };
94601     } catch (std::exception& e) {
94602       {
94603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94604       };
94605     } catch (Dali::DaliException e) {
94606       {
94607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94608       };
94609     } catch (...) {
94610       {
94611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94612       };
94613     }
94614   }
94615
94616   jresult = (void *)result;
94617   return jresult;
94618 }
94619
94620
94621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94622   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94623   int arg2 ;
94624   Dali::Actor *arg3 = 0 ;
94625
94626   arg1 = (std::vector< Dali::Actor > *)jarg1;
94627   arg2 = (int)jarg2;
94628   arg3 = (Dali::Actor *)jarg3;
94629   if (!arg3) {
94630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94631     return ;
94632   }
94633   {
94634     try {
94635       try {
94636         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
94637       }
94638       catch(std::out_of_range &_e) {
94639         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94640         return ;
94641       }
94642
94643     } catch (std::out_of_range& e) {
94644       {
94645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94646       };
94647     } catch (std::exception& e) {
94648       {
94649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94650       };
94651     } catch (Dali::DaliException e) {
94652       {
94653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94654       };
94655     } catch (...) {
94656       {
94657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94658       };
94659     }
94660   }
94661
94662 }
94663
94664
94665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94666   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94667   int arg2 ;
94668   std::vector< Dali::Actor > *arg3 = 0 ;
94669
94670   arg1 = (std::vector< Dali::Actor > *)jarg1;
94671   arg2 = (int)jarg2;
94672   arg3 = (std::vector< Dali::Actor > *)jarg3;
94673   if (!arg3) {
94674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94675     return ;
94676   }
94677   {
94678     try {
94679       try {
94680         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94681       }
94682       catch(std::out_of_range &_e) {
94683         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94684         return ;
94685       }
94686
94687     } catch (std::out_of_range& e) {
94688       {
94689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94690       };
94691     } catch (std::exception& e) {
94692       {
94693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94694       };
94695     } catch (Dali::DaliException e) {
94696       {
94697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94698       };
94699     } catch (...) {
94700       {
94701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94702       };
94703     }
94704   }
94705
94706 }
94707
94708
94709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
94710   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94711   int arg2 ;
94712
94713   arg1 = (std::vector< Dali::Actor > *)jarg1;
94714   arg2 = (int)jarg2;
94715   {
94716     try {
94717       try {
94718         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
94719       }
94720       catch(std::out_of_range &_e) {
94721         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94722         return ;
94723       }
94724
94725     } catch (std::out_of_range& e) {
94726       {
94727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94728       };
94729     } catch (std::exception& e) {
94730       {
94731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94732       };
94733     } catch (Dali::DaliException e) {
94734       {
94735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94736       };
94737     } catch (...) {
94738       {
94739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94740       };
94741     }
94742   }
94743
94744 }
94745
94746
94747 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94748   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94749   int arg2 ;
94750   int arg3 ;
94751
94752   arg1 = (std::vector< Dali::Actor > *)jarg1;
94753   arg2 = (int)jarg2;
94754   arg3 = (int)jarg3;
94755   {
94756     try {
94757       try {
94758         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94759       }
94760       catch(std::out_of_range &_e) {
94761         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94762         return ;
94763       }
94764       catch(std::invalid_argument &_e) {
94765         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94766         return ;
94767       }
94768
94769     } catch (std::out_of_range& e) {
94770       {
94771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94772       };
94773     } catch (std::exception& e) {
94774       {
94775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94776       };
94777     } catch (Dali::DaliException e) {
94778       {
94779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94780       };
94781     } catch (...) {
94782       {
94783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94784       };
94785     }
94786   }
94787
94788 }
94789
94790
94791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94792   void * jresult ;
94793   Dali::Actor *arg1 = 0 ;
94794   int arg2 ;
94795   std::vector< Dali::Actor > *result = 0 ;
94796
94797   arg1 = (Dali::Actor *)jarg1;
94798   if (!arg1) {
94799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94800     return 0;
94801   }
94802   arg2 = (int)jarg2;
94803   {
94804     try {
94805       try {
94806         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94807       }
94808       catch(std::out_of_range &_e) {
94809         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94810         return 0;
94811       }
94812
94813     } catch (std::out_of_range& e) {
94814       {
94815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94816       };
94817     } catch (std::exception& e) {
94818       {
94819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94820       };
94821     } catch (Dali::DaliException e) {
94822       {
94823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94824       };
94825     } catch (...) {
94826       {
94827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94828       };
94829     }
94830   }
94831
94832   jresult = (void *)result;
94833   return jresult;
94834 }
94835
94836
94837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94838   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94839
94840   arg1 = (std::vector< Dali::Actor > *)jarg1;
94841   {
94842     try {
94843       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94844     } catch (std::out_of_range& e) {
94845       {
94846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94847       };
94848     } catch (std::exception& e) {
94849       {
94850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94851       };
94852     } catch (Dali::DaliException e) {
94853       {
94854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94855       };
94856     } catch (...) {
94857       {
94858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94859       };
94860     }
94861   }
94862
94863 }
94864
94865
94866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94867   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94868   int arg2 ;
94869   int arg3 ;
94870
94871   arg1 = (std::vector< Dali::Actor > *)jarg1;
94872   arg2 = (int)jarg2;
94873   arg3 = (int)jarg3;
94874   {
94875     try {
94876       try {
94877         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94878       }
94879       catch(std::out_of_range &_e) {
94880         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94881         return ;
94882       }
94883       catch(std::invalid_argument &_e) {
94884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94885         return ;
94886       }
94887
94888     } catch (std::out_of_range& e) {
94889       {
94890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94891       };
94892     } catch (std::exception& e) {
94893       {
94894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94895       };
94896     } catch (Dali::DaliException e) {
94897       {
94898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94899       };
94900     } catch (...) {
94901       {
94902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94903       };
94904     }
94905   }
94906
94907 }
94908
94909
94910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94911   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94912   int arg2 ;
94913   std::vector< Dali::Actor > *arg3 = 0 ;
94914
94915   arg1 = (std::vector< Dali::Actor > *)jarg1;
94916   arg2 = (int)jarg2;
94917   arg3 = (std::vector< Dali::Actor > *)jarg3;
94918   if (!arg3) {
94919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94920     return ;
94921   }
94922   {
94923     try {
94924       try {
94925         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94926       }
94927       catch(std::out_of_range &_e) {
94928         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94929         return ;
94930       }
94931
94932     } catch (std::out_of_range& e) {
94933       {
94934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94935       };
94936     } catch (std::exception& e) {
94937       {
94938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94939       };
94940     } catch (Dali::DaliException e) {
94941       {
94942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94943       };
94944     } catch (...) {
94945       {
94946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94947       };
94948     }
94949   }
94950
94951 }
94952
94953
94954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94955   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94956
94957   arg1 = (std::vector< Dali::Actor > *)jarg1;
94958   {
94959     try {
94960       delete arg1;
94961     } catch (std::out_of_range& e) {
94962       {
94963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94964       };
94965     } catch (std::exception& e) {
94966       {
94967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94968       };
94969     } catch (Dali::DaliException e) {
94970       {
94971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94972       };
94973     } catch (...) {
94974       {
94975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94976       };
94977     }
94978   }
94979
94980 }
94981
94982
94983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94984   unsigned int jresult ;
94985   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94986   bool result;
94987
94988   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94989   {
94990     try {
94991       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94992     } catch (std::out_of_range& e) {
94993       {
94994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94995       };
94996     } catch (std::exception& e) {
94997       {
94998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94999       };
95000     } catch (Dali::DaliException e) {
95001       {
95002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95003       };
95004     } catch (...) {
95005       {
95006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95007       };
95008     }
95009   }
95010
95011   jresult = result;
95012   return jresult;
95013 }
95014
95015
95016 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
95017   unsigned long jresult ;
95018   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95019   std::size_t result;
95020
95021   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95022   {
95023     try {
95024       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
95025     } catch (std::out_of_range& e) {
95026       {
95027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95028       };
95029     } catch (std::exception& e) {
95030       {
95031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95032       };
95033     } catch (Dali::DaliException e) {
95034       {
95035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95036       };
95037     } catch (...) {
95038       {
95039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95040       };
95041     }
95042   }
95043
95044   jresult = (unsigned long)result;
95045   return jresult;
95046 }
95047
95048
95049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95050   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95051   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95052
95053   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95054   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95055   {
95056     try {
95057       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95058     } catch (std::out_of_range& e) {
95059       {
95060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95061       };
95062     } catch (std::exception& e) {
95063       {
95064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95065       };
95066     } catch (Dali::DaliException e) {
95067       {
95068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95069       };
95070     } catch (...) {
95071       {
95072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95073       };
95074     }
95075   }
95076
95077 }
95078
95079
95080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95081   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95082   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95083
95084   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95085   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95086   {
95087     try {
95088       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95089     } catch (std::out_of_range& e) {
95090       {
95091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95092       };
95093     } catch (std::exception& e) {
95094       {
95095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95096       };
95097     } catch (Dali::DaliException e) {
95098       {
95099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95100       };
95101     } catch (...) {
95102       {
95103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95104       };
95105     }
95106   }
95107
95108 }
95109
95110
95111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95112   unsigned int jresult ;
95113   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95114   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95115   bool result;
95116
95117   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95118   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95119   if (!arg2) {
95120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95121     return 0;
95122   }
95123   {
95124     try {
95125       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95126     } catch (std::out_of_range& e) {
95127       {
95128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95129       };
95130     } catch (std::exception& e) {
95131       {
95132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95133       };
95134     } catch (Dali::DaliException e) {
95135       {
95136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95137       };
95138     } catch (...) {
95139       {
95140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95141       };
95142     }
95143   }
95144
95145   jresult = result;
95146   return jresult;
95147 }
95148
95149
95150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95151   void * jresult ;
95152   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95153
95154   {
95155     try {
95156       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95157     } catch (std::out_of_range& e) {
95158       {
95159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95160       };
95161     } catch (std::exception& e) {
95162       {
95163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95164       };
95165     } catch (Dali::DaliException e) {
95166       {
95167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95168       };
95169     } catch (...) {
95170       {
95171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95172       };
95173     }
95174   }
95175
95176   jresult = (void *)result;
95177   return jresult;
95178 }
95179
95180
95181 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95182   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95183
95184   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95185   {
95186     try {
95187       delete arg1;
95188     } catch (std::out_of_range& e) {
95189       {
95190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95191       };
95192     } catch (std::exception& e) {
95193       {
95194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95195       };
95196     } catch (Dali::DaliException e) {
95197       {
95198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95199       };
95200     } catch (...) {
95201       {
95202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95203       };
95204     }
95205   }
95206
95207 }
95208
95209
95210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95211   unsigned int jresult ;
95212   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95213   bool result;
95214
95215   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95216   {
95217     try {
95218       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);
95219     } catch (std::out_of_range& e) {
95220       {
95221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95222       };
95223     } catch (std::exception& e) {
95224       {
95225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95226       };
95227     } catch (Dali::DaliException e) {
95228       {
95229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95230       };
95231     } catch (...) {
95232       {
95233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95234       };
95235     }
95236   }
95237
95238   jresult = result;
95239   return jresult;
95240 }
95241
95242
95243 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95244   unsigned long jresult ;
95245   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95246   std::size_t result;
95247
95248   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95249   {
95250     try {
95251       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);
95252     } catch (std::out_of_range& e) {
95253       {
95254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95255       };
95256     } catch (std::exception& e) {
95257       {
95258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95259       };
95260     } catch (Dali::DaliException e) {
95261       {
95262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95263       };
95264     } catch (...) {
95265       {
95266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95267       };
95268     }
95269   }
95270
95271   jresult = (unsigned long)result;
95272   return jresult;
95273 }
95274
95275
95276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95277   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95278   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95279
95280   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95281   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95282   {
95283     try {
95284       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95285     } catch (std::out_of_range& e) {
95286       {
95287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95288       };
95289     } catch (std::exception& e) {
95290       {
95291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95292       };
95293     } catch (Dali::DaliException e) {
95294       {
95295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95296       };
95297     } catch (...) {
95298       {
95299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95300       };
95301     }
95302   }
95303
95304 }
95305
95306
95307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95308   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95309   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95310
95311   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95312   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95313   {
95314     try {
95315       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95316     } catch (std::out_of_range& e) {
95317       {
95318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95319       };
95320     } catch (std::exception& e) {
95321       {
95322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95323       };
95324     } catch (Dali::DaliException e) {
95325       {
95326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95327       };
95328     } catch (...) {
95329       {
95330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95331       };
95332     }
95333   }
95334
95335 }
95336
95337
95338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95339   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95340   Dali::Actor arg2 ;
95341   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95342   Dali::Actor *argp2 ;
95343
95344   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95345   argp2 = (Dali::Actor *)jarg2;
95346   if (!argp2) {
95347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95348     return ;
95349   }
95350   arg2 = *argp2;
95351   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95352   {
95353     try {
95354       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95355     } catch (std::out_of_range& e) {
95356       {
95357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95358       };
95359     } catch (std::exception& e) {
95360       {
95361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95362       };
95363     } catch (Dali::DaliException e) {
95364       {
95365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95366       };
95367     } catch (...) {
95368       {
95369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95370       };
95371     }
95372   }
95373
95374 }
95375
95376
95377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95378   void * jresult ;
95379   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95380
95381   {
95382     try {
95383       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95384     } catch (std::out_of_range& e) {
95385       {
95386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95387       };
95388     } catch (std::exception& e) {
95389       {
95390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95391       };
95392     } catch (Dali::DaliException e) {
95393       {
95394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95395       };
95396     } catch (...) {
95397       {
95398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95399       };
95400     }
95401   }
95402
95403   jresult = (void *)result;
95404   return jresult;
95405 }
95406
95407
95408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95409   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95410
95411   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95412   {
95413     try {
95414       delete arg1;
95415     } catch (std::out_of_range& e) {
95416       {
95417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95418       };
95419     } catch (std::exception& e) {
95420       {
95421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95422       };
95423     } catch (Dali::DaliException e) {
95424       {
95425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95426       };
95427     } catch (...) {
95428       {
95429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95430       };
95431     }
95432   }
95433
95434 }
95435
95436
95437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95438   unsigned int jresult ;
95439   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95440   bool result;
95441
95442   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95443   {
95444     try {
95445       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95446     } catch (std::out_of_range& e) {
95447       {
95448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95449       };
95450     } catch (std::exception& e) {
95451       {
95452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95453       };
95454     } catch (Dali::DaliException e) {
95455       {
95456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95457       };
95458     } catch (...) {
95459       {
95460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95461       };
95462     }
95463   }
95464
95465   jresult = result;
95466   return jresult;
95467 }
95468
95469
95470 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95471   unsigned long jresult ;
95472   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95473   std::size_t result;
95474
95475   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95476   {
95477     try {
95478       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95479     } catch (std::out_of_range& e) {
95480       {
95481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95482       };
95483     } catch (std::exception& e) {
95484       {
95485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95486       };
95487     } catch (Dali::DaliException e) {
95488       {
95489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95490       };
95491     } catch (...) {
95492       {
95493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95494       };
95495     }
95496   }
95497
95498   jresult = (unsigned long)result;
95499   return jresult;
95500 }
95501
95502
95503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95504   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95505   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95506
95507   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95508   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95509   {
95510     try {
95511       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95512     } catch (std::out_of_range& e) {
95513       {
95514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95515       };
95516     } catch (std::exception& e) {
95517       {
95518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95519       };
95520     } catch (Dali::DaliException e) {
95521       {
95522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95523       };
95524     } catch (...) {
95525       {
95526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95527       };
95528     }
95529   }
95530
95531 }
95532
95533
95534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95535   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95536   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95537
95538   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95539   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95540   {
95541     try {
95542       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95543     } catch (std::out_of_range& e) {
95544       {
95545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95546       };
95547     } catch (std::exception& e) {
95548       {
95549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95550       };
95551     } catch (Dali::DaliException e) {
95552       {
95553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95554       };
95555     } catch (...) {
95556       {
95557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95558       };
95559     }
95560   }
95561
95562 }
95563
95564
95565 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95566   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95567   Dali::Actor arg2 ;
95568   Dali::Actor arg3 ;
95569   Dali::Actor *argp2 ;
95570   Dali::Actor *argp3 ;
95571
95572   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95573   argp2 = (Dali::Actor *)jarg2;
95574   if (!argp2) {
95575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95576     return ;
95577   }
95578   arg2 = *argp2;
95579   argp3 = (Dali::Actor *)jarg3;
95580   if (!argp3) {
95581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95582     return ;
95583   }
95584   arg3 = *argp3;
95585   {
95586     try {
95587       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95588     } catch (std::out_of_range& e) {
95589       {
95590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95591       };
95592     } catch (std::exception& e) {
95593       {
95594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95595       };
95596     } catch (Dali::DaliException e) {
95597       {
95598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95599       };
95600     } catch (...) {
95601       {
95602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95603       };
95604     }
95605   }
95606
95607 }
95608
95609
95610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95611   void * jresult ;
95612   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95613
95614   {
95615     try {
95616       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95617     } catch (std::out_of_range& e) {
95618       {
95619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95620       };
95621     } catch (std::exception& e) {
95622       {
95623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95624       };
95625     } catch (Dali::DaliException e) {
95626       {
95627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95628       };
95629     } catch (...) {
95630       {
95631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95632       };
95633     }
95634   }
95635
95636   jresult = (void *)result;
95637   return jresult;
95638 }
95639
95640
95641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
95642   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95643
95644   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95645   {
95646     try {
95647       delete arg1;
95648     } catch (std::out_of_range& e) {
95649       {
95650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95651       };
95652     } catch (std::exception& e) {
95653       {
95654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95655       };
95656     } catch (Dali::DaliException e) {
95657       {
95658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95659       };
95660     } catch (...) {
95661       {
95662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95663       };
95664     }
95665   }
95666
95667 }
95668
95669
95670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
95671   unsigned int jresult ;
95672   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95673   bool result;
95674
95675   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95676   {
95677     try {
95678       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95679     } catch (std::out_of_range& e) {
95680       {
95681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95682       };
95683     } catch (std::exception& e) {
95684       {
95685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95686       };
95687     } catch (Dali::DaliException e) {
95688       {
95689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95690       };
95691     } catch (...) {
95692       {
95693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95694       };
95695     }
95696   }
95697
95698   jresult = result;
95699   return jresult;
95700 }
95701
95702
95703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
95704   unsigned long jresult ;
95705   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95706   std::size_t result;
95707
95708   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95709   {
95710     try {
95711       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95712     } catch (std::out_of_range& e) {
95713       {
95714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95715       };
95716     } catch (std::exception& e) {
95717       {
95718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95719       };
95720     } catch (Dali::DaliException e) {
95721       {
95722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95723       };
95724     } catch (...) {
95725       {
95726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95727       };
95728     }
95729   }
95730
95731   jresult = (unsigned long)result;
95732   return jresult;
95733 }
95734
95735
95736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95737   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95738   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95739
95740   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95741   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95742   {
95743     try {
95744       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95745     } catch (std::out_of_range& e) {
95746       {
95747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95748       };
95749     } catch (std::exception& e) {
95750       {
95751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95752       };
95753     } catch (Dali::DaliException e) {
95754       {
95755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95756       };
95757     } catch (...) {
95758       {
95759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95760       };
95761     }
95762   }
95763
95764 }
95765
95766
95767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95768   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95769   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95770
95771   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95772   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95773   {
95774     try {
95775       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95776     } catch (std::out_of_range& e) {
95777       {
95778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95779       };
95780     } catch (std::exception& e) {
95781       {
95782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95783       };
95784     } catch (Dali::DaliException e) {
95785       {
95786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95787       };
95788     } catch (...) {
95789       {
95790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95791       };
95792     }
95793   }
95794
95795 }
95796
95797
95798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95799   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95800   Dali::Actor arg2 ;
95801   bool arg3 ;
95802   Dali::Actor *argp2 ;
95803
95804   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95805   argp2 = (Dali::Actor *)jarg2;
95806   if (!argp2) {
95807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95808     return ;
95809   }
95810   arg2 = *argp2;
95811   arg3 = jarg3 ? true : false;
95812   {
95813     try {
95814       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95815     } catch (std::out_of_range& e) {
95816       {
95817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95818       };
95819     } catch (std::exception& e) {
95820       {
95821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95822       };
95823     } catch (Dali::DaliException e) {
95824       {
95825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95826       };
95827     } catch (...) {
95828       {
95829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95830       };
95831     }
95832   }
95833
95834 }
95835
95836
95837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95838   void * jresult ;
95839   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95840
95841   {
95842     try {
95843       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95844     } catch (std::out_of_range& e) {
95845       {
95846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95847       };
95848     } catch (std::exception& e) {
95849       {
95850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95851       };
95852     } catch (Dali::DaliException e) {
95853       {
95854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95855       };
95856     } catch (...) {
95857       {
95858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95859       };
95860     }
95861   }
95862
95863   jresult = (void *)result;
95864   return jresult;
95865 }
95866
95867
95868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95869   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95870
95871   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95872   {
95873     try {
95874       delete arg1;
95875     } catch (std::out_of_range& e) {
95876       {
95877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95878       };
95879     } catch (std::exception& e) {
95880       {
95881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95882       };
95883     } catch (Dali::DaliException e) {
95884       {
95885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95886       };
95887     } catch (...) {
95888       {
95889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95890       };
95891     }
95892   }
95893
95894 }
95895
95896
95897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95898   unsigned int jresult ;
95899   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95900   bool result;
95901
95902   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95903   {
95904     try {
95905       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);
95906     } catch (std::out_of_range& e) {
95907       {
95908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95909       };
95910     } catch (std::exception& e) {
95911       {
95912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95913       };
95914     } catch (Dali::DaliException e) {
95915       {
95916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95917       };
95918     } catch (...) {
95919       {
95920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95921       };
95922     }
95923   }
95924
95925   jresult = result;
95926   return jresult;
95927 }
95928
95929
95930 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95931   unsigned long jresult ;
95932   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95933   std::size_t result;
95934
95935   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95936   {
95937     try {
95938       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);
95939     } catch (std::out_of_range& e) {
95940       {
95941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95942       };
95943     } catch (std::exception& e) {
95944       {
95945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95946       };
95947     } catch (Dali::DaliException e) {
95948       {
95949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95950       };
95951     } catch (...) {
95952       {
95953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95954       };
95955     }
95956   }
95957
95958   jresult = (unsigned long)result;
95959   return jresult;
95960 }
95961
95962
95963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95964   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95965   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95966
95967   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95968   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95969   {
95970     try {
95971       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95972     } catch (std::out_of_range& e) {
95973       {
95974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95975       };
95976     } catch (std::exception& e) {
95977       {
95978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95979       };
95980     } catch (Dali::DaliException e) {
95981       {
95982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95983       };
95984     } catch (...) {
95985       {
95986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95987       };
95988     }
95989   }
95990
95991 }
95992
95993
95994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95995   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95996   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95997
95998   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95999   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
96000   {
96001     try {
96002       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
96003     } catch (std::out_of_range& e) {
96004       {
96005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96006       };
96007     } catch (std::exception& e) {
96008       {
96009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96010       };
96011     } catch (Dali::DaliException e) {
96012       {
96013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96014       };
96015     } catch (...) {
96016       {
96017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96018       };
96019     }
96020   }
96021
96022 }
96023
96024
96025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96026   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96027   Dali::Toolkit::StyleManager arg2 ;
96028   Dali::StyleChange::Type arg3 ;
96029   Dali::Toolkit::StyleManager *argp2 ;
96030
96031   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96032   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
96033   if (!argp2) {
96034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96035     return ;
96036   }
96037   arg2 = *argp2;
96038   arg3 = (Dali::StyleChange::Type)jarg3;
96039   {
96040     try {
96041       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96042     } catch (std::out_of_range& e) {
96043       {
96044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96045       };
96046     } catch (std::exception& e) {
96047       {
96048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96049       };
96050     } catch (Dali::DaliException e) {
96051       {
96052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96053       };
96054     } catch (...) {
96055       {
96056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96057       };
96058     }
96059   }
96060
96061 }
96062
96063
96064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96065   void * jresult ;
96066   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96067
96068   {
96069     try {
96070       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96071     } catch (std::out_of_range& e) {
96072       {
96073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96074       };
96075     } catch (std::exception& e) {
96076       {
96077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96078       };
96079     } catch (Dali::DaliException e) {
96080       {
96081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96082       };
96083     } catch (...) {
96084       {
96085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96086       };
96087     }
96088   }
96089
96090   jresult = (void *)result;
96091   return jresult;
96092 }
96093
96094
96095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96096   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96097
96098   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96099   {
96100     try {
96101       delete arg1;
96102     } catch (std::out_of_range& e) {
96103       {
96104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96105       };
96106     } catch (std::exception& e) {
96107       {
96108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96109       };
96110     } catch (Dali::DaliException e) {
96111       {
96112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96113       };
96114     } catch (...) {
96115       {
96116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96117       };
96118     }
96119   }
96120
96121 }
96122
96123
96124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96125   unsigned int jresult ;
96126   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96127   bool result;
96128
96129   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96130   {
96131     try {
96132       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96133     } catch (std::out_of_range& e) {
96134       {
96135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96136       };
96137     } catch (std::exception& e) {
96138       {
96139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96140       };
96141     } catch (Dali::DaliException e) {
96142       {
96143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96144       };
96145     } catch (...) {
96146       {
96147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96148       };
96149     }
96150   }
96151
96152   jresult = result;
96153   return jresult;
96154 }
96155
96156
96157 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96158   unsigned long jresult ;
96159   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96160   std::size_t result;
96161
96162   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96163   {
96164     try {
96165       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96166     } catch (std::out_of_range& e) {
96167       {
96168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96169       };
96170     } catch (std::exception& e) {
96171       {
96172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96173       };
96174     } catch (Dali::DaliException e) {
96175       {
96176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96177       };
96178     } catch (...) {
96179       {
96180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96181       };
96182     }
96183   }
96184
96185   jresult = (unsigned long)result;
96186   return jresult;
96187 }
96188
96189
96190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96191   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96192   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96193
96194   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96195   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96196   {
96197     try {
96198       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96199     } catch (std::out_of_range& e) {
96200       {
96201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96202       };
96203     } catch (std::exception& e) {
96204       {
96205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96206       };
96207     } catch (Dali::DaliException e) {
96208       {
96209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96210       };
96211     } catch (...) {
96212       {
96213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96214       };
96215     }
96216   }
96217
96218 }
96219
96220
96221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96222   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96223   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96224
96225   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96226   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96227   {
96228     try {
96229       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96230     } catch (std::out_of_range& e) {
96231       {
96232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96233       };
96234     } catch (std::exception& e) {
96235       {
96236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96237       };
96238     } catch (Dali::DaliException e) {
96239       {
96240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96241       };
96242     } catch (...) {
96243       {
96244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96245       };
96246     }
96247   }
96248
96249 }
96250
96251
96252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96253   unsigned int jresult ;
96254   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96255   Dali::Toolkit::Button arg2 ;
96256   Dali::Toolkit::Button *argp2 ;
96257   bool result;
96258
96259   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96260   argp2 = (Dali::Toolkit::Button *)jarg2;
96261   if (!argp2) {
96262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96263     return 0;
96264   }
96265   arg2 = *argp2;
96266   {
96267     try {
96268       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96269     } catch (std::out_of_range& e) {
96270       {
96271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96272       };
96273     } catch (std::exception& e) {
96274       {
96275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96276       };
96277     } catch (Dali::DaliException e) {
96278       {
96279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96280       };
96281     } catch (...) {
96282       {
96283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96284       };
96285     }
96286   }
96287
96288   jresult = result;
96289   return jresult;
96290 }
96291
96292
96293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96294   void * jresult ;
96295   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96296
96297   {
96298     try {
96299       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96300     } catch (std::out_of_range& e) {
96301       {
96302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96303       };
96304     } catch (std::exception& e) {
96305       {
96306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96307       };
96308     } catch (Dali::DaliException e) {
96309       {
96310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96311       };
96312     } catch (...) {
96313       {
96314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96315       };
96316     }
96317   }
96318
96319   jresult = (void *)result;
96320   return jresult;
96321 }
96322
96323
96324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96325   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96326
96327   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96328   {
96329     try {
96330       delete arg1;
96331     } catch (std::out_of_range& e) {
96332       {
96333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96334       };
96335     } catch (std::exception& e) {
96336       {
96337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96338       };
96339     } catch (Dali::DaliException e) {
96340       {
96341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96342       };
96343     } catch (...) {
96344       {
96345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96346       };
96347     }
96348   }
96349
96350 }
96351
96352
96353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96354   unsigned int jresult ;
96355   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96356   bool result;
96357
96358   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96359   {
96360     try {
96361       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96362     } catch (std::out_of_range& e) {
96363       {
96364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96365       };
96366     } catch (std::exception& e) {
96367       {
96368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96369       };
96370     } catch (Dali::DaliException e) {
96371       {
96372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96373       };
96374     } catch (...) {
96375       {
96376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96377       };
96378     }
96379   }
96380
96381   jresult = result;
96382   return jresult;
96383 }
96384
96385
96386 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96387   unsigned long jresult ;
96388   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96389   std::size_t result;
96390
96391   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96392   {
96393     try {
96394       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96395     } catch (std::out_of_range& e) {
96396       {
96397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96398       };
96399     } catch (std::exception& e) {
96400       {
96401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96402       };
96403     } catch (Dali::DaliException e) {
96404       {
96405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96406       };
96407     } catch (...) {
96408       {
96409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96410       };
96411     }
96412   }
96413
96414   jresult = (unsigned long)result;
96415   return jresult;
96416 }
96417
96418
96419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96420   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96421   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96422
96423   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96424   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96425   {
96426     try {
96427       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96428     } catch (std::out_of_range& e) {
96429       {
96430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96431       };
96432     } catch (std::exception& e) {
96433       {
96434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96435       };
96436     } catch (Dali::DaliException e) {
96437       {
96438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96439       };
96440     } catch (...) {
96441       {
96442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96443       };
96444     }
96445   }
96446
96447 }
96448
96449
96450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96451   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96452   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96453
96454   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96455   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96456   {
96457     try {
96458       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96459     } catch (std::out_of_range& e) {
96460       {
96461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96462       };
96463     } catch (std::exception& e) {
96464       {
96465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96466       };
96467     } catch (Dali::DaliException e) {
96468       {
96469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96470       };
96471     } catch (...) {
96472       {
96473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96474       };
96475     }
96476   }
96477
96478 }
96479
96480
96481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96482   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96483   Dali::Toolkit::GaussianBlurView arg2 ;
96484   Dali::Toolkit::GaussianBlurView *argp2 ;
96485
96486   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96487   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96488   if (!argp2) {
96489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96490     return ;
96491   }
96492   arg2 = *argp2;
96493   {
96494     try {
96495       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96496     } catch (std::out_of_range& e) {
96497       {
96498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96499       };
96500     } catch (std::exception& e) {
96501       {
96502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96503       };
96504     } catch (Dali::DaliException e) {
96505       {
96506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96507       };
96508     } catch (...) {
96509       {
96510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96511       };
96512     }
96513   }
96514
96515 }
96516
96517
96518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96519   void * jresult ;
96520   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96521
96522   {
96523     try {
96524       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96525     } catch (std::out_of_range& e) {
96526       {
96527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96528       };
96529     } catch (std::exception& e) {
96530       {
96531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96532       };
96533     } catch (Dali::DaliException e) {
96534       {
96535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96536       };
96537     } catch (...) {
96538       {
96539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96540       };
96541     }
96542   }
96543
96544   jresult = (void *)result;
96545   return jresult;
96546 }
96547
96548
96549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96550   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96551
96552   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96553   {
96554     try {
96555       delete arg1;
96556     } catch (std::out_of_range& e) {
96557       {
96558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96559       };
96560     } catch (std::exception& e) {
96561       {
96562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96563       };
96564     } catch (Dali::DaliException e) {
96565       {
96566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96567       };
96568     } catch (...) {
96569       {
96570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96571       };
96572     }
96573   }
96574
96575 }
96576
96577
96578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96579   unsigned int jresult ;
96580   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96581   bool result;
96582
96583   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96584   {
96585     try {
96586       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);
96587     } catch (std::out_of_range& e) {
96588       {
96589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96590       };
96591     } catch (std::exception& e) {
96592       {
96593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96594       };
96595     } catch (Dali::DaliException e) {
96596       {
96597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96598       };
96599     } catch (...) {
96600       {
96601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96602       };
96603     }
96604   }
96605
96606   jresult = result;
96607   return jresult;
96608 }
96609
96610
96611 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96612   unsigned long jresult ;
96613   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96614   std::size_t result;
96615
96616   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96617   {
96618     try {
96619       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);
96620     } catch (std::out_of_range& e) {
96621       {
96622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96623       };
96624     } catch (std::exception& e) {
96625       {
96626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96627       };
96628     } catch (Dali::DaliException e) {
96629       {
96630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96631       };
96632     } catch (...) {
96633       {
96634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96635       };
96636     }
96637   }
96638
96639   jresult = (unsigned long)result;
96640   return jresult;
96641 }
96642
96643
96644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
96645   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96646   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96647
96648   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96649   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96650   {
96651     try {
96652       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
96653     } catch (std::out_of_range& e) {
96654       {
96655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96656       };
96657     } catch (std::exception& e) {
96658       {
96659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96660       };
96661     } catch (Dali::DaliException e) {
96662       {
96663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96664       };
96665     } catch (...) {
96666       {
96667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96668       };
96669     }
96670   }
96671
96672 }
96673
96674
96675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
96676   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96677   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96678
96679   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96680   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96681   {
96682     try {
96683       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96684     } catch (std::out_of_range& e) {
96685       {
96686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96687       };
96688     } catch (std::exception& e) {
96689       {
96690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96691       };
96692     } catch (Dali::DaliException e) {
96693       {
96694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96695       };
96696     } catch (...) {
96697       {
96698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96699       };
96700     }
96701   }
96702
96703 }
96704
96705
96706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
96707   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96708   Dali::Toolkit::PageTurnView arg2 ;
96709   unsigned int arg3 ;
96710   bool arg4 ;
96711   Dali::Toolkit::PageTurnView *argp2 ;
96712
96713   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96714   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96715   if (!argp2) {
96716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96717     return ;
96718   }
96719   arg2 = *argp2;
96720   arg3 = (unsigned int)jarg3;
96721   arg4 = jarg4 ? true : false;
96722   {
96723     try {
96724       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96725     } catch (std::out_of_range& e) {
96726       {
96727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96728       };
96729     } catch (std::exception& e) {
96730       {
96731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96732       };
96733     } catch (Dali::DaliException e) {
96734       {
96735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96736       };
96737     } catch (...) {
96738       {
96739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96740       };
96741     }
96742   }
96743
96744 }
96745
96746
96747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96748   void * jresult ;
96749   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96750
96751   {
96752     try {
96753       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96754     } catch (std::out_of_range& e) {
96755       {
96756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96757       };
96758     } catch (std::exception& e) {
96759       {
96760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96761       };
96762     } catch (Dali::DaliException e) {
96763       {
96764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96765       };
96766     } catch (...) {
96767       {
96768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96769       };
96770     }
96771   }
96772
96773   jresult = (void *)result;
96774   return jresult;
96775 }
96776
96777
96778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96779   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96780
96781   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96782   {
96783     try {
96784       delete arg1;
96785     } catch (std::out_of_range& e) {
96786       {
96787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96788       };
96789     } catch (std::exception& e) {
96790       {
96791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96792       };
96793     } catch (Dali::DaliException e) {
96794       {
96795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96796       };
96797     } catch (...) {
96798       {
96799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96800       };
96801     }
96802   }
96803
96804 }
96805
96806
96807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96808   unsigned int jresult ;
96809   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96810   bool result;
96811
96812   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96813   {
96814     try {
96815       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96816     } catch (std::out_of_range& e) {
96817       {
96818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96819       };
96820     } catch (std::exception& e) {
96821       {
96822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96823       };
96824     } catch (Dali::DaliException e) {
96825       {
96826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96827       };
96828     } catch (...) {
96829       {
96830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96831       };
96832     }
96833   }
96834
96835   jresult = result;
96836   return jresult;
96837 }
96838
96839
96840 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96841   unsigned long jresult ;
96842   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96843   std::size_t result;
96844
96845   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96846   {
96847     try {
96848       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96849     } catch (std::out_of_range& e) {
96850       {
96851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96852       };
96853     } catch (std::exception& e) {
96854       {
96855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96856       };
96857     } catch (Dali::DaliException e) {
96858       {
96859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96860       };
96861     } catch (...) {
96862       {
96863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96864       };
96865     }
96866   }
96867
96868   jresult = (unsigned long)result;
96869   return jresult;
96870 }
96871
96872
96873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96874   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96875   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96876
96877   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96878   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96879   {
96880     try {
96881       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96882     } catch (std::out_of_range& e) {
96883       {
96884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96885       };
96886     } catch (std::exception& e) {
96887       {
96888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96889       };
96890     } catch (Dali::DaliException e) {
96891       {
96892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96893       };
96894     } catch (...) {
96895       {
96896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96897       };
96898     }
96899   }
96900
96901 }
96902
96903
96904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96905   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96906   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96907
96908   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96909   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96910   {
96911     try {
96912       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96913     } catch (std::out_of_range& e) {
96914       {
96915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96916       };
96917     } catch (std::exception& e) {
96918       {
96919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96920       };
96921     } catch (Dali::DaliException e) {
96922       {
96923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96924       };
96925     } catch (...) {
96926       {
96927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96928       };
96929     }
96930   }
96931
96932 }
96933
96934
96935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96936   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96937   Dali::Toolkit::PageTurnView arg2 ;
96938   Dali::Toolkit::PageTurnView *argp2 ;
96939
96940   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96941   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96942   if (!argp2) {
96943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96944     return ;
96945   }
96946   arg2 = *argp2;
96947   {
96948     try {
96949       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96950     } catch (std::out_of_range& e) {
96951       {
96952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96953       };
96954     } catch (std::exception& e) {
96955       {
96956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96957       };
96958     } catch (Dali::DaliException e) {
96959       {
96960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96961       };
96962     } catch (...) {
96963       {
96964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96965       };
96966     }
96967   }
96968
96969 }
96970
96971
96972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96973   void * jresult ;
96974   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96975
96976   {
96977     try {
96978       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96979     } catch (std::out_of_range& e) {
96980       {
96981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96982       };
96983     } catch (std::exception& e) {
96984       {
96985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96986       };
96987     } catch (Dali::DaliException e) {
96988       {
96989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96990       };
96991     } catch (...) {
96992       {
96993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96994       };
96995     }
96996   }
96997
96998   jresult = (void *)result;
96999   return jresult;
97000 }
97001
97002
97003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
97004   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
97005
97006   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
97007   {
97008     try {
97009       delete arg1;
97010     } catch (std::out_of_range& e) {
97011       {
97012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97013       };
97014     } catch (std::exception& e) {
97015       {
97016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97017       };
97018     } catch (Dali::DaliException e) {
97019       {
97020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97021       };
97022     } catch (...) {
97023       {
97024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97025       };
97026     }
97027   }
97028
97029 }
97030
97031
97032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
97033   unsigned int jresult ;
97034   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97035   bool result;
97036
97037   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97038   {
97039     try {
97040       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);
97041     } catch (std::out_of_range& e) {
97042       {
97043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97044       };
97045     } catch (std::exception& e) {
97046       {
97047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97048       };
97049     } catch (Dali::DaliException e) {
97050       {
97051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97052       };
97053     } catch (...) {
97054       {
97055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97056       };
97057     }
97058   }
97059
97060   jresult = result;
97061   return jresult;
97062 }
97063
97064
97065 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97066   unsigned long jresult ;
97067   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97068   std::size_t result;
97069
97070   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97071   {
97072     try {
97073       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);
97074     } catch (std::out_of_range& e) {
97075       {
97076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97077       };
97078     } catch (std::exception& e) {
97079       {
97080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97081       };
97082     } catch (Dali::DaliException e) {
97083       {
97084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97085       };
97086     } catch (...) {
97087       {
97088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97089       };
97090     }
97091   }
97092
97093   jresult = (unsigned long)result;
97094   return jresult;
97095 }
97096
97097
97098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97099   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97100   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97101
97102   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97103   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97104   {
97105     try {
97106       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97107     } catch (std::out_of_range& e) {
97108       {
97109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97110       };
97111     } catch (std::exception& e) {
97112       {
97113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97114       };
97115     } catch (Dali::DaliException e) {
97116       {
97117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97118       };
97119     } catch (...) {
97120       {
97121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97122       };
97123     }
97124   }
97125
97126 }
97127
97128
97129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97130   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97131   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97132
97133   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97134   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97135   {
97136     try {
97137       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97138     } catch (std::out_of_range& e) {
97139       {
97140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97141       };
97142     } catch (std::exception& e) {
97143       {
97144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97145       };
97146     } catch (Dali::DaliException e) {
97147       {
97148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97149       };
97150     } catch (...) {
97151       {
97152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97153       };
97154     }
97155   }
97156
97157 }
97158
97159
97160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97161   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97162   Dali::Toolkit::ProgressBar arg2 ;
97163   float arg3 ;
97164   float arg4 ;
97165   Dali::Toolkit::ProgressBar *argp2 ;
97166
97167   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97168   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97169   if (!argp2) {
97170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97171     return ;
97172   }
97173   arg2 = *argp2;
97174   arg3 = (float)jarg3;
97175   arg4 = (float)jarg4;
97176   {
97177     try {
97178       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97179     } catch (std::out_of_range& e) {
97180       {
97181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97182       };
97183     } catch (std::exception& e) {
97184       {
97185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97186       };
97187     } catch (Dali::DaliException e) {
97188       {
97189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97190       };
97191     } catch (...) {
97192       {
97193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97194       };
97195     }
97196   }
97197
97198 }
97199
97200
97201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97202   void * jresult ;
97203   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97204
97205   {
97206     try {
97207       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97208     } catch (std::out_of_range& e) {
97209       {
97210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97211       };
97212     } catch (std::exception& e) {
97213       {
97214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97215       };
97216     } catch (Dali::DaliException e) {
97217       {
97218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97219       };
97220     } catch (...) {
97221       {
97222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97223       };
97224     }
97225   }
97226
97227   jresult = (void *)result;
97228   return jresult;
97229 }
97230
97231
97232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97233   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97234
97235   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97236   {
97237     try {
97238       delete arg1;
97239     } catch (std::out_of_range& e) {
97240       {
97241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97242       };
97243     } catch (std::exception& e) {
97244       {
97245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97246       };
97247     } catch (Dali::DaliException e) {
97248       {
97249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97250       };
97251     } catch (...) {
97252       {
97253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97254       };
97255     }
97256   }
97257
97258 }
97259
97260
97261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97262   unsigned int jresult ;
97263   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97264   bool result;
97265
97266   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97267   {
97268     try {
97269       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);
97270     } catch (std::out_of_range& e) {
97271       {
97272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97273       };
97274     } catch (std::exception& e) {
97275       {
97276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97277       };
97278     } catch (Dali::DaliException e) {
97279       {
97280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97281       };
97282     } catch (...) {
97283       {
97284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97285       };
97286     }
97287   }
97288
97289   jresult = result;
97290   return jresult;
97291 }
97292
97293
97294 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97295   unsigned long jresult ;
97296   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97297   std::size_t result;
97298
97299   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97300   {
97301     try {
97302       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);
97303     } catch (std::out_of_range& e) {
97304       {
97305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97306       };
97307     } catch (std::exception& e) {
97308       {
97309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97310       };
97311     } catch (Dali::DaliException e) {
97312       {
97313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97314       };
97315     } catch (...) {
97316       {
97317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97318       };
97319     }
97320   }
97321
97322   jresult = (unsigned long)result;
97323   return jresult;
97324 }
97325
97326
97327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97328   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97329   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97330
97331   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97332   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97333   {
97334     try {
97335       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97336     } catch (std::out_of_range& e) {
97337       {
97338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97339       };
97340     } catch (std::exception& e) {
97341       {
97342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97343       };
97344     } catch (Dali::DaliException e) {
97345       {
97346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97347       };
97348     } catch (...) {
97349       {
97350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97351       };
97352     }
97353   }
97354
97355 }
97356
97357
97358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97359   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97360   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97361
97362   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97363   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97364   {
97365     try {
97366       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97367     } catch (std::out_of_range& e) {
97368       {
97369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97370       };
97371     } catch (std::exception& e) {
97372       {
97373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97374       };
97375     } catch (Dali::DaliException e) {
97376       {
97377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97378       };
97379     } catch (...) {
97380       {
97381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97382       };
97383     }
97384   }
97385
97386 }
97387
97388
97389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97390   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97391   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97392
97393   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97394   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97395   if (!arg2) {
97396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97397     return ;
97398   }
97399   {
97400     try {
97401       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
97402     } catch (std::out_of_range& e) {
97403       {
97404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97405       };
97406     } catch (std::exception& e) {
97407       {
97408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97409       };
97410     } catch (Dali::DaliException e) {
97411       {
97412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97413       };
97414     } catch (...) {
97415       {
97416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97417       };
97418     }
97419   }
97420
97421 }
97422
97423
97424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
97425   void * jresult ;
97426   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97427
97428   {
97429     try {
97430       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97431     } catch (std::out_of_range& e) {
97432       {
97433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97434       };
97435     } catch (std::exception& e) {
97436       {
97437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97438       };
97439     } catch (Dali::DaliException e) {
97440       {
97441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97442       };
97443     } catch (...) {
97444       {
97445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97446       };
97447     }
97448   }
97449
97450   jresult = (void *)result;
97451   return jresult;
97452 }
97453
97454
97455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97456   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97457
97458   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97459   {
97460     try {
97461       delete arg1;
97462     } catch (std::out_of_range& e) {
97463       {
97464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97465       };
97466     } catch (std::exception& e) {
97467       {
97468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97469       };
97470     } catch (Dali::DaliException e) {
97471       {
97472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97473       };
97474     } catch (...) {
97475       {
97476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97477       };
97478     }
97479   }
97480
97481 }
97482
97483
97484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97485   unsigned int jresult ;
97486   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97487   bool result;
97488
97489   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97490   {
97491     try {
97492       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97493     } catch (std::out_of_range& e) {
97494       {
97495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97496       };
97497     } catch (std::exception& e) {
97498       {
97499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97500       };
97501     } catch (Dali::DaliException e) {
97502       {
97503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97504       };
97505     } catch (...) {
97506       {
97507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97508       };
97509     }
97510   }
97511
97512   jresult = result;
97513   return jresult;
97514 }
97515
97516
97517 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97518   unsigned long jresult ;
97519   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97520   std::size_t result;
97521
97522   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97523   {
97524     try {
97525       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97526     } catch (std::out_of_range& e) {
97527       {
97528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97529       };
97530     } catch (std::exception& e) {
97531       {
97532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97533       };
97534     } catch (Dali::DaliException e) {
97535       {
97536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97537       };
97538     } catch (...) {
97539       {
97540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97541       };
97542     }
97543   }
97544
97545   jresult = (unsigned long)result;
97546   return jresult;
97547 }
97548
97549
97550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97551   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97552   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97553
97554   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97555   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97556   {
97557     try {
97558       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97559     } catch (std::out_of_range& e) {
97560       {
97561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97562       };
97563     } catch (std::exception& e) {
97564       {
97565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97566       };
97567     } catch (Dali::DaliException e) {
97568       {
97569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97570       };
97571     } catch (...) {
97572       {
97573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97574       };
97575     }
97576   }
97577
97578 }
97579
97580
97581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97582   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97583   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97584
97585   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97586   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97587   {
97588     try {
97589       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97590     } catch (std::out_of_range& e) {
97591       {
97592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97593       };
97594     } catch (std::exception& e) {
97595       {
97596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97597       };
97598     } catch (Dali::DaliException e) {
97599       {
97600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97601       };
97602     } catch (...) {
97603       {
97604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97605       };
97606     }
97607   }
97608
97609 }
97610
97611
97612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97613   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97614   Dali::Vector2 *arg2 = 0 ;
97615
97616   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97617   arg2 = (Dali::Vector2 *)jarg2;
97618   if (!arg2) {
97619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97620     return ;
97621   }
97622   {
97623     try {
97624       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
97625     } catch (std::out_of_range& e) {
97626       {
97627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97628       };
97629     } catch (std::exception& e) {
97630       {
97631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97632       };
97633     } catch (Dali::DaliException e) {
97634       {
97635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97636       };
97637     } catch (...) {
97638       {
97639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97640       };
97641     }
97642   }
97643
97644 }
97645
97646
97647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
97648   void * jresult ;
97649   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
97650
97651   {
97652     try {
97653       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
97654     } catch (std::out_of_range& e) {
97655       {
97656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97657       };
97658     } catch (std::exception& e) {
97659       {
97660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97661       };
97662     } catch (Dali::DaliException e) {
97663       {
97664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97665       };
97666     } catch (...) {
97667       {
97668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97669       };
97670     }
97671   }
97672
97673   jresult = (void *)result;
97674   return jresult;
97675 }
97676
97677
97678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
97679   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97680
97681   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97682   {
97683     try {
97684       delete arg1;
97685     } catch (std::out_of_range& e) {
97686       {
97687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97688       };
97689     } catch (std::exception& e) {
97690       {
97691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97692       };
97693     } catch (Dali::DaliException e) {
97694       {
97695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97696       };
97697     } catch (...) {
97698       {
97699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97700       };
97701     }
97702   }
97703
97704 }
97705
97706
97707
97708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
97709   unsigned int jresult ;
97710   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97711   bool result;
97712
97713   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97714   {
97715     try {
97716       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);
97717     } catch (std::out_of_range& e) {
97718       {
97719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97720       };
97721     } catch (std::exception& e) {
97722       {
97723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97724       };
97725     } catch (Dali::DaliException e) {
97726       {
97727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97728       };
97729     } catch (...) {
97730       {
97731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97732       };
97733     }
97734   }
97735
97736   jresult = result;
97737   return jresult;
97738 }
97739
97740
97741 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97742   unsigned long jresult ;
97743   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97744   std::size_t result;
97745
97746   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97747   {
97748     try {
97749       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);
97750     } catch (std::out_of_range& e) {
97751       {
97752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97753       };
97754     } catch (std::exception& e) {
97755       {
97756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97757       };
97758     } catch (Dali::DaliException e) {
97759       {
97760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97761       };
97762     } catch (...) {
97763       {
97764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97765       };
97766     }
97767   }
97768
97769   jresult = (unsigned long)result;
97770   return jresult;
97771 }
97772
97773
97774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97775   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97776   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97777
97778   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97779   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97780   {
97781     try {
97782       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97783     } catch (std::out_of_range& e) {
97784       {
97785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97786       };
97787     } catch (std::exception& e) {
97788       {
97789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97790       };
97791     } catch (Dali::DaliException e) {
97792       {
97793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97794       };
97795     } catch (...) {
97796       {
97797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97798       };
97799     }
97800   }
97801
97802 }
97803
97804
97805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97806   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97807   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97808
97809   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97810   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97811   {
97812     try {
97813       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97814     } catch (std::out_of_range& e) {
97815       {
97816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97817       };
97818     } catch (std::exception& e) {
97819       {
97820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97821       };
97822     } catch (Dali::DaliException e) {
97823       {
97824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97825       };
97826     } catch (...) {
97827       {
97828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97829       };
97830     }
97831   }
97832
97833 }
97834
97835
97836 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97837   unsigned int jresult ;
97838   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97839   Dali::Toolkit::Control arg2 ;
97840   Dali::KeyEvent *arg3 = 0 ;
97841   Dali::Toolkit::Control *argp2 ;
97842   bool result;
97843
97844   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97845   argp2 = (Dali::Toolkit::Control *)jarg2;
97846   if (!argp2) {
97847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97848     return 0;
97849   }
97850   arg2 = *argp2;
97851   arg3 = (Dali::KeyEvent *)jarg3;
97852   if (!arg3) {
97853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97854     return 0;
97855   }
97856   {
97857     try {
97858       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);
97859     } catch (std::out_of_range& e) {
97860       {
97861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97862       };
97863     } catch (std::exception& e) {
97864       {
97865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97866       };
97867     } catch (Dali::DaliException e) {
97868       {
97869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97870       };
97871     } catch (...) {
97872       {
97873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97874       };
97875     }
97876   }
97877
97878   jresult = result;
97879   return jresult;
97880 }
97881
97882
97883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97884   void * jresult ;
97885   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97886
97887   {
97888     try {
97889       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97890     } catch (std::out_of_range& e) {
97891       {
97892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97893       };
97894     } catch (std::exception& e) {
97895       {
97896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97897       };
97898     } catch (Dali::DaliException e) {
97899       {
97900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97901       };
97902     } catch (...) {
97903       {
97904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97905       };
97906     }
97907   }
97908
97909   jresult = (void *)result;
97910   return jresult;
97911 }
97912
97913
97914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97915   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97916
97917   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97918   {
97919     try {
97920       delete arg1;
97921     } catch (std::out_of_range& e) {
97922       {
97923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97924       };
97925     } catch (std::exception& e) {
97926       {
97927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97928       };
97929     } catch (Dali::DaliException e) {
97930       {
97931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97932       };
97933     } catch (...) {
97934       {
97935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97936       };
97937     }
97938   }
97939
97940 }
97941
97942
97943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97944   unsigned int jresult ;
97945   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97946   bool result;
97947
97948   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97949   {
97950     try {
97951       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97952     } catch (std::out_of_range& e) {
97953       {
97954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97955       };
97956     } catch (std::exception& e) {
97957       {
97958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97959       };
97960     } catch (Dali::DaliException e) {
97961       {
97962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97963       };
97964     } catch (...) {
97965       {
97966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97967       };
97968     }
97969   }
97970
97971   jresult = result;
97972   return jresult;
97973 }
97974
97975
97976 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97977   unsigned long jresult ;
97978   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97979   std::size_t result;
97980
97981   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97982   {
97983     try {
97984       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97985     } catch (std::out_of_range& e) {
97986       {
97987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97988       };
97989     } catch (std::exception& e) {
97990       {
97991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97992       };
97993     } catch (Dali::DaliException e) {
97994       {
97995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97996       };
97997     } catch (...) {
97998       {
97999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98000       };
98001     }
98002   }
98003
98004   jresult = (unsigned long)result;
98005   return jresult;
98006 }
98007
98008
98009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
98010   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98011   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98012
98013   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98014   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98015   {
98016     try {
98017       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98018     } catch (std::out_of_range& e) {
98019       {
98020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98021       };
98022     } catch (std::exception& e) {
98023       {
98024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98025       };
98026     } catch (Dali::DaliException e) {
98027       {
98028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98029       };
98030     } catch (...) {
98031       {
98032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98033       };
98034     }
98035   }
98036
98037 }
98038
98039
98040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98041   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98042   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98043
98044   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98045   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98046   {
98047     try {
98048       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98049     } catch (std::out_of_range& e) {
98050       {
98051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98052       };
98053     } catch (std::exception& e) {
98054       {
98055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98056       };
98057     } catch (Dali::DaliException e) {
98058       {
98059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98060       };
98061     } catch (...) {
98062       {
98063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98064       };
98065     }
98066   }
98067
98068 }
98069
98070
98071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98072   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98073   Dali::Toolkit::Control arg2 ;
98074   Dali::Toolkit::Control *argp2 ;
98075
98076   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98077   argp2 = (Dali::Toolkit::Control *)jarg2;
98078   if (!argp2) {
98079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98080     return ;
98081   }
98082   arg2 = *argp2;
98083   {
98084     try {
98085       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98086     } catch (std::out_of_range& e) {
98087       {
98088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98089       };
98090     } catch (std::exception& e) {
98091       {
98092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98093       };
98094     } catch (Dali::DaliException e) {
98095       {
98096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98097       };
98098     } catch (...) {
98099       {
98100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98101       };
98102     }
98103   }
98104
98105 }
98106
98107
98108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98109   void * jresult ;
98110   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98111
98112   {
98113     try {
98114       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98115     } catch (std::out_of_range& e) {
98116       {
98117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98118       };
98119     } catch (std::exception& e) {
98120       {
98121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98122       };
98123     } catch (Dali::DaliException e) {
98124       {
98125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98126       };
98127     } catch (...) {
98128       {
98129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98130       };
98131     }
98132   }
98133
98134   jresult = (void *)result;
98135   return jresult;
98136 }
98137
98138
98139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98140   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98141
98142   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98143   {
98144     try {
98145       delete arg1;
98146     } catch (std::out_of_range& e) {
98147       {
98148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98149       };
98150     } catch (std::exception& e) {
98151       {
98152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98153       };
98154     } catch (Dali::DaliException e) {
98155       {
98156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98157       };
98158     } catch (...) {
98159       {
98160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98161       };
98162     }
98163   }
98164
98165 }
98166
98167
98168 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98169   unsigned int jresult ;
98170   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98171   bool result;
98172
98173   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98174   {
98175     try {
98176       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98177     } catch (std::out_of_range& e) {
98178       {
98179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98180       };
98181     } catch (std::exception& e) {
98182       {
98183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98184       };
98185     } catch (Dali::DaliException e) {
98186       {
98187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98188       };
98189     } catch (...) {
98190       {
98191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98192       };
98193     }
98194   }
98195
98196   jresult = result;
98197   return jresult;
98198 }
98199
98200
98201 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98202   unsigned long jresult ;
98203   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98204   std::size_t result;
98205
98206   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98207   {
98208     try {
98209       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98210     } catch (std::out_of_range& e) {
98211       {
98212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98213       };
98214     } catch (std::exception& e) {
98215       {
98216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98217       };
98218     } catch (Dali::DaliException e) {
98219       {
98220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98221       };
98222     } catch (...) {
98223       {
98224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98225       };
98226     }
98227   }
98228
98229   jresult = (unsigned long)result;
98230   return jresult;
98231 }
98232
98233
98234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98235   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98236   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98237
98238   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98239   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98240   {
98241     try {
98242       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98243     } catch (std::out_of_range& e) {
98244       {
98245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98246       };
98247     } catch (std::exception& e) {
98248       {
98249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98250       };
98251     } catch (Dali::DaliException e) {
98252       {
98253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98254       };
98255     } catch (...) {
98256       {
98257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98258       };
98259     }
98260   }
98261
98262 }
98263
98264
98265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98266   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98267   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98268
98269   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98270   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98271   {
98272     try {
98273       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98274     } catch (std::out_of_range& e) {
98275       {
98276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98277       };
98278     } catch (std::exception& e) {
98279       {
98280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98281       };
98282     } catch (Dali::DaliException e) {
98283       {
98284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98285       };
98286     } catch (...) {
98287       {
98288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98289       };
98290     }
98291   }
98292
98293 }
98294
98295
98296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98297   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98298   Dali::Toolkit::VideoView *arg2 = 0 ;
98299
98300   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98301   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98302   if (!arg2) {
98303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98304     return ;
98305   }
98306   {
98307     try {
98308       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
98309     } catch (std::out_of_range& e) {
98310       {
98311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98312       };
98313     } catch (std::exception& e) {
98314       {
98315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98316       };
98317     } catch (Dali::DaliException e) {
98318       {
98319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98320       };
98321     } catch (...) {
98322       {
98323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98324       };
98325     }
98326   }
98327
98328 }
98329
98330
98331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
98332   void * jresult ;
98333   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98334
98335   {
98336     try {
98337       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98338     } catch (std::out_of_range& e) {
98339       {
98340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98341       };
98342     } catch (std::exception& e) {
98343       {
98344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98345       };
98346     } catch (Dali::DaliException e) {
98347       {
98348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98349       };
98350     } catch (...) {
98351       {
98352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98353       };
98354     }
98355   }
98356
98357   jresult = (void *)result;
98358   return jresult;
98359 }
98360
98361
98362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98363   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98364
98365   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98366   {
98367     try {
98368       delete arg1;
98369     } catch (std::out_of_range& e) {
98370       {
98371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98372       };
98373     } catch (std::exception& e) {
98374       {
98375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98376       };
98377     } catch (Dali::DaliException e) {
98378       {
98379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98380       };
98381     } catch (...) {
98382       {
98383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98384       };
98385     }
98386   }
98387
98388 }
98389
98390
98391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98392   unsigned int jresult ;
98393   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98394   bool result;
98395
98396   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98397   {
98398     try {
98399       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98400     } catch (std::out_of_range& e) {
98401       {
98402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98403       };
98404     } catch (std::exception& e) {
98405       {
98406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98407       };
98408     } catch (Dali::DaliException e) {
98409       {
98410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98411       };
98412     } catch (...) {
98413       {
98414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98415       };
98416     }
98417   }
98418
98419   jresult = result;
98420   return jresult;
98421 }
98422
98423
98424 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98425   unsigned long jresult ;
98426   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98427   std::size_t result;
98428
98429   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98430   {
98431     try {
98432       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98433     } catch (std::out_of_range& e) {
98434       {
98435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98436       };
98437     } catch (std::exception& e) {
98438       {
98439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98440       };
98441     } catch (Dali::DaliException e) {
98442       {
98443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98444       };
98445     } catch (...) {
98446       {
98447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98448       };
98449     }
98450   }
98451
98452   jresult = (unsigned long)result;
98453   return jresult;
98454 }
98455
98456
98457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98458   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98459   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98460
98461   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98462   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98463   {
98464     try {
98465       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98466     } catch (std::out_of_range& e) {
98467       {
98468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98469       };
98470     } catch (std::exception& e) {
98471       {
98472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98473       };
98474     } catch (Dali::DaliException e) {
98475       {
98476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98477       };
98478     } catch (...) {
98479       {
98480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98481       };
98482     }
98483   }
98484
98485 }
98486
98487
98488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98489   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98490   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98491
98492   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98493   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98494   {
98495     try {
98496       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98497     } catch (std::out_of_range& e) {
98498       {
98499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98500       };
98501     } catch (std::exception& e) {
98502       {
98503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98504       };
98505     } catch (Dali::DaliException e) {
98506       {
98507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98508       };
98509     } catch (...) {
98510       {
98511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98512       };
98513     }
98514   }
98515
98516 }
98517
98518
98519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98520   unsigned int jresult ;
98521   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98522   Dali::Toolkit::Slider arg2 ;
98523   float arg3 ;
98524   Dali::Toolkit::Slider *argp2 ;
98525   bool result;
98526
98527   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98528   argp2 = (Dali::Toolkit::Slider *)jarg2;
98529   if (!argp2) {
98530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98531     return 0;
98532   }
98533   arg2 = *argp2;
98534   arg3 = (float)jarg3;
98535   {
98536     try {
98537       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98538     } catch (std::out_of_range& e) {
98539       {
98540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98541       };
98542     } catch (std::exception& e) {
98543       {
98544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98545       };
98546     } catch (Dali::DaliException e) {
98547       {
98548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98549       };
98550     } catch (...) {
98551       {
98552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98553       };
98554     }
98555   }
98556
98557   jresult = result;
98558   return jresult;
98559 }
98560
98561
98562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98563   void * jresult ;
98564   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98565
98566   {
98567     try {
98568       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98569     } catch (std::out_of_range& e) {
98570       {
98571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98572       };
98573     } catch (std::exception& e) {
98574       {
98575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98576       };
98577     } catch (Dali::DaliException e) {
98578       {
98579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98580       };
98581     } catch (...) {
98582       {
98583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98584       };
98585     }
98586   }
98587
98588   jresult = (void *)result;
98589   return jresult;
98590 }
98591
98592
98593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98594   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98595
98596   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98597   {
98598     try {
98599       delete arg1;
98600     } catch (std::out_of_range& e) {
98601       {
98602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98603       };
98604     } catch (std::exception& e) {
98605       {
98606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98607       };
98608     } catch (Dali::DaliException e) {
98609       {
98610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98611       };
98612     } catch (...) {
98613       {
98614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98615       };
98616     }
98617   }
98618
98619 }
98620
98621
98622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98623   unsigned int jresult ;
98624   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98625   bool result;
98626
98627   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98628   {
98629     try {
98630       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98631     } catch (std::out_of_range& e) {
98632       {
98633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98634       };
98635     } catch (std::exception& e) {
98636       {
98637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98638       };
98639     } catch (Dali::DaliException e) {
98640       {
98641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98642       };
98643     } catch (...) {
98644       {
98645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98646       };
98647     }
98648   }
98649
98650   jresult = result;
98651   return jresult;
98652 }
98653
98654
98655 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
98656   unsigned long jresult ;
98657   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98658   std::size_t result;
98659
98660   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98661   {
98662     try {
98663       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98664     } catch (std::out_of_range& e) {
98665       {
98666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98667       };
98668     } catch (std::exception& e) {
98669       {
98670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98671       };
98672     } catch (Dali::DaliException e) {
98673       {
98674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98675       };
98676     } catch (...) {
98677       {
98678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98679       };
98680     }
98681   }
98682
98683   jresult = (unsigned long)result;
98684   return jresult;
98685 }
98686
98687
98688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
98689   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98690   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98691
98692   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98693   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98694   {
98695     try {
98696       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
98697     } catch (std::out_of_range& e) {
98698       {
98699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98700       };
98701     } catch (std::exception& e) {
98702       {
98703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98704       };
98705     } catch (Dali::DaliException e) {
98706       {
98707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98708       };
98709     } catch (...) {
98710       {
98711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98712       };
98713     }
98714   }
98715
98716 }
98717
98718
98719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
98720   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98721   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98722
98723   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98724   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98725   {
98726     try {
98727       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
98728     } catch (std::out_of_range& e) {
98729       {
98730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98731       };
98732     } catch (std::exception& e) {
98733       {
98734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98735       };
98736     } catch (Dali::DaliException e) {
98737       {
98738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98739       };
98740     } catch (...) {
98741       {
98742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98743       };
98744     }
98745   }
98746
98747 }
98748
98749
98750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98751   unsigned int jresult ;
98752   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98753   Dali::Toolkit::Slider arg2 ;
98754   int arg3 ;
98755   Dali::Toolkit::Slider *argp2 ;
98756   bool result;
98757
98758   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98759   argp2 = (Dali::Toolkit::Slider *)jarg2;
98760   if (!argp2) {
98761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98762     return 0;
98763   }
98764   arg2 = *argp2;
98765   arg3 = (int)jarg3;
98766   {
98767     try {
98768       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98769     } catch (std::out_of_range& e) {
98770       {
98771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98772       };
98773     } catch (std::exception& e) {
98774       {
98775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98776       };
98777     } catch (Dali::DaliException e) {
98778       {
98779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98780       };
98781     } catch (...) {
98782       {
98783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98784       };
98785     }
98786   }
98787
98788   jresult = result;
98789   return jresult;
98790 }
98791
98792
98793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98794   void * jresult ;
98795   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98796
98797   {
98798     try {
98799       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98800     } catch (std::out_of_range& e) {
98801       {
98802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98803       };
98804     } catch (std::exception& e) {
98805       {
98806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98807       };
98808     } catch (Dali::DaliException e) {
98809       {
98810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98811       };
98812     } catch (...) {
98813       {
98814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98815       };
98816     }
98817   }
98818
98819   jresult = (void *)result;
98820   return jresult;
98821 }
98822
98823
98824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98825   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98826
98827   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98828   {
98829     try {
98830       delete arg1;
98831     } catch (std::out_of_range& e) {
98832       {
98833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98834       };
98835     } catch (std::exception& e) {
98836       {
98837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98838       };
98839     } catch (Dali::DaliException e) {
98840       {
98841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98842       };
98843     } catch (...) {
98844       {
98845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98846       };
98847     }
98848   }
98849
98850 }
98851
98852
98853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98854   void * jresult ;
98855   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98856
98857   {
98858     try {
98859       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98860     } catch (std::out_of_range& e) {
98861       {
98862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98863       };
98864     } catch (std::exception& e) {
98865       {
98866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98867       };
98868     } catch (Dali::DaliException e) {
98869       {
98870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98871       };
98872     } catch (...) {
98873       {
98874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98875       };
98876     }
98877   }
98878
98879   jresult = (void *)result;
98880   return jresult;
98881 }
98882
98883
98884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98885   void * jresult ;
98886   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98887   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98888
98889   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98890   {
98891     try {
98892       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98893     } catch (std::out_of_range& e) {
98894       {
98895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98896       };
98897     } catch (std::exception& e) {
98898       {
98899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98900       };
98901     } catch (Dali::DaliException e) {
98902       {
98903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98904       };
98905     } catch (...) {
98906       {
98907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98908       };
98909     }
98910   }
98911
98912   jresult = (void *)result;
98913   return jresult;
98914 }
98915
98916
98917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98918   void * jresult ;
98919   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98920   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98921
98922   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98923   if (!arg1) {
98924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98925     return 0;
98926   }
98927   {
98928     try {
98929       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98930     } catch (std::out_of_range& e) {
98931       {
98932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98933       };
98934     } catch (std::exception& e) {
98935       {
98936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98937       };
98938     } catch (Dali::DaliException e) {
98939       {
98940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98941       };
98942     } catch (...) {
98943       {
98944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98945       };
98946     }
98947   }
98948
98949   jresult = (void *)result;
98950   return jresult;
98951 }
98952
98953
98954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98955   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98956
98957   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98958   {
98959     try {
98960       delete arg1;
98961     } catch (std::out_of_range& e) {
98962       {
98963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98964       };
98965     } catch (std::exception& e) {
98966       {
98967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98968       };
98969     } catch (Dali::DaliException e) {
98970       {
98971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98972       };
98973     } catch (...) {
98974       {
98975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98976       };
98977     }
98978   }
98979
98980 }
98981
98982
98983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98984   void * jresult ;
98985   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98986   Dali::Toolkit::Ruler *result = 0 ;
98987
98988   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98989   {
98990     try {
98991       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98992     } catch (std::out_of_range& e) {
98993       {
98994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98995       };
98996     } catch (std::exception& e) {
98997       {
98998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98999       };
99000     } catch (Dali::DaliException e) {
99001       {
99002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99003       };
99004     } catch (...) {
99005       {
99006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99007       };
99008     }
99009   }
99010
99011   jresult = (void *)result;
99012   return jresult;
99013 }
99014
99015
99016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
99017   void * jresult ;
99018   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99019   Dali::Toolkit::Ruler *result = 0 ;
99020
99021   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99022   {
99023     try {
99024       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
99025     } catch (std::out_of_range& e) {
99026       {
99027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99028       };
99029     } catch (std::exception& e) {
99030       {
99031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99032       };
99033     } catch (Dali::DaliException e) {
99034       {
99035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99036       };
99037     } catch (...) {
99038       {
99039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99040       };
99041     }
99042   }
99043
99044   jresult = (void *)result;
99045   return jresult;
99046 }
99047
99048
99049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99050   void * jresult ;
99051   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99052   Dali::Toolkit::Ruler *result = 0 ;
99053
99054   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99055   {
99056     try {
99057       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99058     } catch (std::out_of_range& e) {
99059       {
99060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99061       };
99062     } catch (std::exception& e) {
99063       {
99064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99065       };
99066     } catch (Dali::DaliException e) {
99067       {
99068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99069       };
99070     } catch (...) {
99071       {
99072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99073       };
99074     }
99075   }
99076
99077   jresult = (void *)result;
99078   return jresult;
99079 }
99080
99081
99082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99083   void * jresult ;
99084   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99085   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99086   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99087
99088   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99089   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99090   if (!arg2) {
99091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99092     return 0;
99093   }
99094   {
99095     try {
99096       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99097     } catch (std::out_of_range& e) {
99098       {
99099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99100       };
99101     } catch (std::exception& e) {
99102       {
99103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99104       };
99105     } catch (Dali::DaliException e) {
99106       {
99107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99108       };
99109     } catch (...) {
99110       {
99111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99112       };
99113     }
99114   }
99115
99116   jresult = (void *)result;
99117   return jresult;
99118 }
99119
99120
99121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99122   void * jresult ;
99123   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99124   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99125   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99126
99127   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99128   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99129   {
99130     try {
99131       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
99132     } catch (std::out_of_range& e) {
99133       {
99134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99135       };
99136     } catch (std::exception& e) {
99137       {
99138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99139       };
99140     } catch (Dali::DaliException e) {
99141       {
99142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99143       };
99144     } catch (...) {
99145       {
99146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99147       };
99148     }
99149   }
99150
99151   jresult = (void *)result;
99152   return jresult;
99153 }
99154
99155
99156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
99157   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99158
99159   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99160   {
99161     try {
99162       (arg1)->Reset();
99163     } catch (std::out_of_range& e) {
99164       {
99165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99166       };
99167     } catch (std::exception& e) {
99168       {
99169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99170       };
99171     } catch (Dali::DaliException e) {
99172       {
99173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99174       };
99175     } catch (...) {
99176       {
99177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99178       };
99179     }
99180   }
99181
99182 }
99183
99184
99185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99186   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99187   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99188
99189   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99190   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99191   {
99192     try {
99193       (arg1)->Reset(arg2);
99194     } catch (std::out_of_range& e) {
99195       {
99196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99197       };
99198     } catch (std::exception& e) {
99199       {
99200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99201       };
99202     } catch (Dali::DaliException e) {
99203       {
99204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99205       };
99206     } catch (...) {
99207       {
99208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99209       };
99210     }
99211   }
99212
99213 }
99214
99215
99216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99217   void * jresult ;
99218   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99219   Dali::Toolkit::Ruler *result = 0 ;
99220
99221   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99222   {
99223     try {
99224       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99225     } catch (std::out_of_range& e) {
99226       {
99227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99228       };
99229     } catch (std::exception& e) {
99230       {
99231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99232       };
99233     } catch (Dali::DaliException e) {
99234       {
99235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99236       };
99237     } catch (...) {
99238       {
99239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99240       };
99241     }
99242   }
99243
99244   jresult = (void *)result;
99245   return jresult;
99246 }
99247
99248
99249 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99250   float jresult ;
99251   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99252   float arg2 ;
99253   float arg3 ;
99254   float result;
99255
99256   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99257   arg2 = (float)jarg2;
99258   arg3 = (float)jarg3;
99259   {
99260     try {
99261       result = (float)(*arg1)->Snap(arg2,arg3);
99262     } catch (std::out_of_range& e) {
99263       {
99264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99265       };
99266     } catch (std::exception& e) {
99267       {
99268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99269       };
99270     } catch (Dali::DaliException e) {
99271       {
99272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99273       };
99274     } catch (...) {
99275       {
99276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99277       };
99278     }
99279   }
99280
99281   jresult = result;
99282   return jresult;
99283 }
99284
99285
99286 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99287   float jresult ;
99288   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99289   float arg2 ;
99290   float result;
99291
99292   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99293   arg2 = (float)jarg2;
99294   {
99295     try {
99296       result = (float)(*arg1)->Snap(arg2);
99297     } catch (std::out_of_range& e) {
99298       {
99299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99300       };
99301     } catch (std::exception& e) {
99302       {
99303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99304       };
99305     } catch (Dali::DaliException e) {
99306       {
99307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99308       };
99309     } catch (...) {
99310       {
99311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99312       };
99313     }
99314   }
99315
99316   jresult = result;
99317   return jresult;
99318 }
99319
99320
99321 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99322   float jresult ;
99323   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99324   unsigned int arg2 ;
99325   unsigned int *arg3 = 0 ;
99326   bool arg4 ;
99327   float result;
99328
99329   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99330   arg2 = (unsigned int)jarg2;
99331   arg3 = (unsigned int *)jarg3;
99332   arg4 = jarg4 ? true : false;
99333   {
99334     try {
99335       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99336     } catch (std::out_of_range& e) {
99337       {
99338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99339       };
99340     } catch (std::exception& e) {
99341       {
99342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99343       };
99344     } catch (Dali::DaliException e) {
99345       {
99346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99347       };
99348     } catch (...) {
99349       {
99350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99351       };
99352     }
99353   }
99354
99355   jresult = result;
99356   return jresult;
99357 }
99358
99359
99360 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99361   unsigned int jresult ;
99362   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99363   float arg2 ;
99364   bool arg3 ;
99365   unsigned int result;
99366
99367   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99368   arg2 = (float)jarg2;
99369   arg3 = jarg3 ? true : false;
99370   {
99371     try {
99372       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99373     } catch (std::out_of_range& e) {
99374       {
99375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99376       };
99377     } catch (std::exception& e) {
99378       {
99379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99380       };
99381     } catch (Dali::DaliException e) {
99382       {
99383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99384       };
99385     } catch (...) {
99386       {
99387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99388       };
99389     }
99390   }
99391
99392   jresult = result;
99393   return jresult;
99394 }
99395
99396
99397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99398   unsigned int jresult ;
99399   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99400   unsigned int result;
99401
99402   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99403   {
99404     try {
99405       result = (unsigned int)(*arg1)->GetTotalPages();
99406     } catch (std::out_of_range& e) {
99407       {
99408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99409       };
99410     } catch (std::exception& e) {
99411       {
99412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99413       };
99414     } catch (Dali::DaliException e) {
99415       {
99416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99417       };
99418     } catch (...) {
99419       {
99420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99421       };
99422     }
99423   }
99424
99425   jresult = result;
99426   return jresult;
99427 }
99428
99429
99430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99431   int jresult ;
99432   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99433   Dali::Toolkit::Ruler::RulerType result;
99434
99435   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99436   {
99437     try {
99438       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99439     } catch (std::out_of_range& e) {
99440       {
99441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99442       };
99443     } catch (std::exception& e) {
99444       {
99445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99446       };
99447     } catch (Dali::DaliException e) {
99448       {
99449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99450       };
99451     } catch (...) {
99452       {
99453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99454       };
99455     }
99456   }
99457
99458   jresult = (int)result;
99459   return jresult;
99460 }
99461
99462
99463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99464   unsigned int jresult ;
99465   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99466   bool result;
99467
99468   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99469   {
99470     try {
99471       result = (bool)(*arg1)->IsEnabled();
99472     } catch (std::out_of_range& e) {
99473       {
99474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99475       };
99476     } catch (std::exception& e) {
99477       {
99478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99479       };
99480     } catch (Dali::DaliException e) {
99481       {
99482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99483       };
99484     } catch (...) {
99485       {
99486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99487       };
99488     }
99489   }
99490
99491   jresult = result;
99492   return jresult;
99493 }
99494
99495
99496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99497   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99498
99499   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99500   {
99501     try {
99502       (*arg1)->Enable();
99503     } catch (std::out_of_range& e) {
99504       {
99505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99506       };
99507     } catch (std::exception& e) {
99508       {
99509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99510       };
99511     } catch (Dali::DaliException e) {
99512       {
99513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99514       };
99515     } catch (...) {
99516       {
99517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99518       };
99519     }
99520   }
99521
99522 }
99523
99524
99525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99526   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99527
99528   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99529   {
99530     try {
99531       (*arg1)->Disable();
99532     } catch (std::out_of_range& e) {
99533       {
99534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99535       };
99536     } catch (std::exception& e) {
99537       {
99538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99539       };
99540     } catch (Dali::DaliException e) {
99541       {
99542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99543       };
99544     } catch (...) {
99545       {
99546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99547       };
99548     }
99549   }
99550
99551 }
99552
99553
99554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99555   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99556   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99557   Dali::Toolkit::RulerDomain *argp2 ;
99558
99559   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99560   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99561   if (!argp2) {
99562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99563     return ;
99564   }
99565   arg2 = *argp2;
99566   {
99567     try {
99568       (*arg1)->SetDomain(arg2);
99569     } catch (std::out_of_range& e) {
99570       {
99571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99572       };
99573     } catch (std::exception& e) {
99574       {
99575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99576       };
99577     } catch (Dali::DaliException e) {
99578       {
99579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99580       };
99581     } catch (...) {
99582       {
99583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99584       };
99585     }
99586   }
99587
99588 }
99589
99590
99591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99592   void * jresult ;
99593   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99594   Dali::Toolkit::RulerDomain *result = 0 ;
99595
99596   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99597   {
99598     try {
99599       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99600     } catch (std::out_of_range& e) {
99601       {
99602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99603       };
99604     } catch (std::exception& e) {
99605       {
99606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99607       };
99608     } catch (Dali::DaliException e) {
99609       {
99610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99611       };
99612     } catch (...) {
99613       {
99614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99615       };
99616     }
99617   }
99618
99619   jresult = (void *)result;
99620   return jresult;
99621 }
99622
99623
99624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99625   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99626
99627   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99628   {
99629     try {
99630       (*arg1)->DisableDomain();
99631     } catch (std::out_of_range& e) {
99632       {
99633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99634       };
99635     } catch (std::exception& e) {
99636       {
99637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99638       };
99639     } catch (Dali::DaliException e) {
99640       {
99641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99642       };
99643     } catch (...) {
99644       {
99645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99646       };
99647     }
99648   }
99649
99650 }
99651
99652
99653 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
99654   float jresult ;
99655   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99656   float arg2 ;
99657   float arg3 ;
99658   float arg4 ;
99659   float result;
99660
99661   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99662   arg2 = (float)jarg2;
99663   arg3 = (float)jarg3;
99664   arg4 = (float)jarg4;
99665   {
99666     try {
99667       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
99668     } catch (std::out_of_range& e) {
99669       {
99670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99671       };
99672     } catch (std::exception& e) {
99673       {
99674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99675       };
99676     } catch (Dali::DaliException e) {
99677       {
99678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99679       };
99680     } catch (...) {
99681       {
99682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99683       };
99684     }
99685   }
99686
99687   jresult = result;
99688   return jresult;
99689 }
99690
99691
99692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
99693   float jresult ;
99694   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99695   float arg2 ;
99696   float arg3 ;
99697   float result;
99698
99699   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99700   arg2 = (float)jarg2;
99701   arg3 = (float)jarg3;
99702   {
99703     try {
99704       result = (float)(*arg1)->Clamp(arg2,arg3);
99705     } catch (std::out_of_range& e) {
99706       {
99707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99708       };
99709     } catch (std::exception& e) {
99710       {
99711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99712       };
99713     } catch (Dali::DaliException e) {
99714       {
99715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99716       };
99717     } catch (...) {
99718       {
99719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99720       };
99721     }
99722   }
99723
99724   jresult = result;
99725   return jresult;
99726 }
99727
99728
99729 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
99730   float jresult ;
99731   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99732   float arg2 ;
99733   float result;
99734
99735   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99736   arg2 = (float)jarg2;
99737   {
99738     try {
99739       result = (float)(*arg1)->Clamp(arg2);
99740     } catch (std::out_of_range& e) {
99741       {
99742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99743       };
99744     } catch (std::exception& e) {
99745       {
99746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99747       };
99748     } catch (Dali::DaliException e) {
99749       {
99750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99751       };
99752     } catch (...) {
99753       {
99754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99755       };
99756     }
99757   }
99758
99759   jresult = result;
99760   return jresult;
99761 }
99762
99763
99764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
99765   float jresult ;
99766   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99767   float arg2 ;
99768   float arg3 ;
99769   float arg4 ;
99770   Dali::Toolkit::ClampState *arg5 = 0 ;
99771   float result;
99772
99773   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99774   arg2 = (float)jarg2;
99775   arg3 = (float)jarg3;
99776   arg4 = (float)jarg4;
99777   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99778   if (!arg5) {
99779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99780     return 0;
99781   }
99782   {
99783     try {
99784       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99785     } catch (std::out_of_range& e) {
99786       {
99787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99788       };
99789     } catch (std::exception& e) {
99790       {
99791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99792       };
99793     } catch (Dali::DaliException e) {
99794       {
99795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99796       };
99797     } catch (...) {
99798       {
99799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99800       };
99801     }
99802   }
99803
99804   jresult = result;
99805   return jresult;
99806 }
99807
99808
99809 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99810   float jresult ;
99811   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99812   float arg2 ;
99813   float arg3 ;
99814   float arg4 ;
99815   float arg5 ;
99816   float result;
99817
99818   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99819   arg2 = (float)jarg2;
99820   arg3 = (float)jarg3;
99821   arg4 = (float)jarg4;
99822   arg5 = (float)jarg5;
99823   {
99824     try {
99825       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99826     } catch (std::out_of_range& e) {
99827       {
99828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99829       };
99830     } catch (std::exception& e) {
99831       {
99832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99833       };
99834     } catch (Dali::DaliException e) {
99835       {
99836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99837       };
99838     } catch (...) {
99839       {
99840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99841       };
99842     }
99843   }
99844
99845   jresult = result;
99846   return jresult;
99847 }
99848
99849
99850 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99851   float jresult ;
99852   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99853   float arg2 ;
99854   float arg3 ;
99855   float arg4 ;
99856   float result;
99857
99858   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99859   arg2 = (float)jarg2;
99860   arg3 = (float)jarg3;
99861   arg4 = (float)jarg4;
99862   {
99863     try {
99864       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99865     } catch (std::out_of_range& e) {
99866       {
99867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99868       };
99869     } catch (std::exception& e) {
99870       {
99871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99872       };
99873     } catch (Dali::DaliException e) {
99874       {
99875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99876       };
99877     } catch (...) {
99878       {
99879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99880       };
99881     }
99882   }
99883
99884   jresult = result;
99885   return jresult;
99886 }
99887
99888
99889 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99890   float jresult ;
99891   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99892   float arg2 ;
99893   float arg3 ;
99894   float result;
99895
99896   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99897   arg2 = (float)jarg2;
99898   arg3 = (float)jarg3;
99899   {
99900     try {
99901       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99902     } catch (std::out_of_range& e) {
99903       {
99904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99905       };
99906     } catch (std::exception& e) {
99907       {
99908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99909       };
99910     } catch (Dali::DaliException e) {
99911       {
99912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99913       };
99914     } catch (...) {
99915       {
99916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99917       };
99918     }
99919   }
99920
99921   jresult = result;
99922   return jresult;
99923 }
99924
99925
99926 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99927   float jresult ;
99928   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99929   float arg2 ;
99930   float result;
99931
99932   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99933   arg2 = (float)jarg2;
99934   {
99935     try {
99936       result = (float)(*arg1)->SnapAndClamp(arg2);
99937     } catch (std::out_of_range& e) {
99938       {
99939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99940       };
99941     } catch (std::exception& e) {
99942       {
99943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99944       };
99945     } catch (Dali::DaliException e) {
99946       {
99947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99948       };
99949     } catch (...) {
99950       {
99951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99952       };
99953     }
99954   }
99955
99956   jresult = result;
99957   return jresult;
99958 }
99959
99960
99961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99962   float jresult ;
99963   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99964   float arg2 ;
99965   float arg3 ;
99966   float arg4 ;
99967   float arg5 ;
99968   Dali::Toolkit::ClampState *arg6 = 0 ;
99969   float result;
99970
99971   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99972   arg2 = (float)jarg2;
99973   arg3 = (float)jarg3;
99974   arg4 = (float)jarg4;
99975   arg5 = (float)jarg5;
99976   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99977   if (!arg6) {
99978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99979     return 0;
99980   }
99981   {
99982     try {
99983       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99984     } catch (std::out_of_range& e) {
99985       {
99986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99987       };
99988     } catch (std::exception& e) {
99989       {
99990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99991       };
99992     } catch (Dali::DaliException e) {
99993       {
99994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99995       };
99996     } catch (...) {
99997       {
99998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99999       };
100000     }
100001   }
100002
100003   jresult = result;
100004   return jresult;
100005 }
100006
100007
100008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
100009   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100010
100011   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100012   {
100013     try {
100014       (*arg1)->Reference();
100015     } catch (std::out_of_range& e) {
100016       {
100017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100018       };
100019     } catch (std::exception& e) {
100020       {
100021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100022       };
100023     } catch (Dali::DaliException e) {
100024       {
100025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100026       };
100027     } catch (...) {
100028       {
100029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100030       };
100031     }
100032   }
100033
100034 }
100035
100036
100037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100038   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100039
100040   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100041   {
100042     try {
100043       (*arg1)->Unreference();
100044     } catch (std::out_of_range& e) {
100045       {
100046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100047       };
100048     } catch (std::exception& e) {
100049       {
100050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100051       };
100052     } catch (Dali::DaliException e) {
100053       {
100054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100055       };
100056     } catch (...) {
100057       {
100058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100059       };
100060     }
100061   }
100062
100063 }
100064
100065
100066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100067   int jresult ;
100068   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100069   int result;
100070
100071   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100072   {
100073     try {
100074       result = (int)(*arg1)->ReferenceCount();
100075     } catch (std::out_of_range& e) {
100076       {
100077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100078       };
100079     } catch (std::exception& e) {
100080       {
100081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100082       };
100083     } catch (Dali::DaliException e) {
100084       {
100085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100086       };
100087     } catch (...) {
100088       {
100089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100090       };
100091     }
100092   }
100093
100094   jresult = result;
100095   return jresult;
100096 }
100097
100098
100099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100100   unsigned int jresult ;
100101   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100102   bool result;
100103
100104   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100105   {
100106     try {
100107       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100108     } catch (std::out_of_range& e) {
100109       {
100110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100111       };
100112     } catch (std::exception& e) {
100113       {
100114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100115       };
100116     } catch (Dali::DaliException e) {
100117       {
100118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100119       };
100120     } catch (...) {
100121       {
100122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100123       };
100124     }
100125   }
100126
100127   jresult = result;
100128   return jresult;
100129 }
100130
100131
100132 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100133   unsigned long jresult ;
100134   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100135   std::size_t result;
100136
100137   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100138   {
100139     try {
100140       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100141     } catch (std::out_of_range& e) {
100142       {
100143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100144       };
100145     } catch (std::exception& e) {
100146       {
100147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100148       };
100149     } catch (Dali::DaliException e) {
100150       {
100151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100152       };
100153     } catch (...) {
100154       {
100155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100156       };
100157     }
100158   }
100159
100160   jresult = (unsigned long)result;
100161   return jresult;
100162 }
100163
100164
100165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100166   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100167   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100168
100169   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100170   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100171   {
100172     try {
100173       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100174     } catch (std::out_of_range& e) {
100175       {
100176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100177       };
100178     } catch (std::exception& e) {
100179       {
100180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100181       };
100182     } catch (Dali::DaliException e) {
100183       {
100184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100185       };
100186     } catch (...) {
100187       {
100188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100189       };
100190     }
100191   }
100192
100193 }
100194
100195
100196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100197   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100198   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100199
100200   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100201   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100202   {
100203     try {
100204       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100205     } catch (std::out_of_range& e) {
100206       {
100207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100208       };
100209     } catch (std::exception& e) {
100210       {
100211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100212       };
100213     } catch (Dali::DaliException e) {
100214       {
100215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100216       };
100217     } catch (...) {
100218       {
100219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100220       };
100221     }
100222   }
100223
100224 }
100225
100226
100227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100228   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100229   Dali::Toolkit::Control arg2 ;
100230   Dali::Toolkit::Control *argp2 ;
100231
100232   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100233   argp2 = (Dali::Toolkit::Control *)jarg2;
100234   if (!argp2) {
100235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100236     return ;
100237   }
100238   arg2 = *argp2;
100239   {
100240     try {
100241       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100242     } catch (std::out_of_range& e) {
100243       {
100244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100245       };
100246     } catch (std::exception& e) {
100247       {
100248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100249       };
100250     } catch (Dali::DaliException e) {
100251       {
100252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100253       };
100254     } catch (...) {
100255       {
100256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100257       };
100258     }
100259   }
100260
100261 }
100262
100263
100264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100265   void * jresult ;
100266   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100267
100268   {
100269     try {
100270       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100271     } catch (std::out_of_range& e) {
100272       {
100273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100274       };
100275     } catch (std::exception& e) {
100276       {
100277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100278       };
100279     } catch (Dali::DaliException e) {
100280       {
100281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100282       };
100283     } catch (...) {
100284       {
100285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100286       };
100287     }
100288   }
100289
100290   jresult = (void *)result;
100291   return jresult;
100292 }
100293
100294
100295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100296   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100297
100298   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100299   {
100300     try {
100301       delete arg1;
100302     } catch (std::out_of_range& e) {
100303       {
100304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100305       };
100306     } catch (std::exception& e) {
100307       {
100308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100309       };
100310     } catch (Dali::DaliException e) {
100311       {
100312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100313       };
100314     } catch (...) {
100315       {
100316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100317       };
100318     }
100319   }
100320
100321 }
100322
100323 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100324   Dali::RefObject *result = NULL;
100325
100326   if (arg1)
100327   {
100328     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100329   }
100330   return result;
100331 }
100332
100333 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100334     return (Dali::RefObject *)jarg1;
100335 }
100336
100337 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100338     return (Dali::SignalObserver *)jarg1;
100339 }
100340
100341 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100342     return (Dali::ConnectionTrackerInterface *)jarg1;
100343 }
100344
100345 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100346     return (Dali::BaseHandle *)jarg1;
100347 }
100348
100349 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100350     return (Dali::BaseHandle *)jarg1;
100351 }
100352
100353 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100354     return (Dali::BaseHandle *)jarg1;
100355 }
100356
100357 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100358     return (Dali::BaseHandle *)jarg1;
100359 }
100360
100361 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100362     return (Dali::BaseHandle *)jarg1;
100363 }
100364
100365 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100366     return (Dali::BaseHandle *)jarg1;
100367 }
100368
100369 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100370     return (Dali::BaseHandle *)jarg1;
100371 }
100372
100373 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100374     return (Dali::BaseHandle *)jarg1;
100375 }
100376
100377 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100378     return (Dali::BaseHandle *)jarg1;
100379 }
100380
100381 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100382     return (Dali::BaseHandle *)jarg1;
100383 }
100384
100385 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100386     return (Dali::BaseHandle *)jarg1;
100387 }
100388
100389 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100390     return (Dali::BaseHandle *)jarg1;
100391 }
100392
100393 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100394     return (Dali::BaseHandle *)jarg1;
100395 }
100396
100397 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100398     return (Dali::Handle *)jarg1;
100399 }
100400
100401 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100402     return (Dali::Handle *)jarg1;
100403 }
100404
100405 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100406     return (Dali::BaseHandle *)jarg1;
100407 }
100408
100409 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100410     return (Dali::BaseHandle *)jarg1;
100411 }
100412
100413 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100414     return (Dali::Handle *)jarg1;
100415 }
100416
100417 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100418     return (Dali::BaseHandle *)jarg1;
100419 }
100420
100421 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100422     return (Dali::Handle *)jarg1;
100423 }
100424
100425 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100426     return (Dali::GestureDetector *)jarg1;
100427 }
100428
100429 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100430     return (Dali::Gesture *)jarg1;
100431 }
100432
100433 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100434     return (Dali::Handle *)jarg1;
100435 }
100436
100437 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100438     return (Dali::Actor *)jarg1;
100439 }
100440
100441 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100442     return (Dali::BaseHandle *)jarg1;
100443 }
100444
100445 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100446     return (Dali::RefObject *)jarg1;
100447 }
100448
100449 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100450     return (Dali::Actor *)jarg1;
100451 }
100452
100453 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100454     return (Dali::GestureDetector *)jarg1;
100455 }
100456
100457 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100458     return (Dali::Gesture *)jarg1;
100459 }
100460
100461 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100462     return (Dali::GestureDetector *)jarg1;
100463 }
100464
100465 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100466     return (Dali::Gesture *)jarg1;
100467 }
100468
100469 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100470     return (Dali::GestureDetector *)jarg1;
100471 }
100472
100473 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100474     return (Dali::Gesture *)jarg1;
100475 }
100476
100477 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100478     return (Dali::BaseHandle *)jarg1;
100479 }
100480
100481 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100482     return (Dali::Handle *)jarg1;
100483 }
100484
100485 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100486     return (Dali::Handle *)jarg1;
100487 }
100488
100489 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100490     return (Dali::Handle *)jarg1;
100491 }
100492
100493 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100494     return (Dali::Image *)jarg1;
100495 }
100496
100497 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100498     return (Dali::Image *)jarg1;
100499 }
100500
100501 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100502     return (Dali::Image *)jarg1;
100503 }
100504
100505 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100506     return (Dali::RefObject *)jarg1;
100507 }
100508
100509 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100510     return (Dali::Image *)jarg1;
100511 }
100512
100513 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100514     return (Dali::Image *)jarg1;
100515 }
100516
100517 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100518     return (Dali::ResourceImage *)jarg1;
100519 }
100520
100521 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100522     return (Dali::Actor *)jarg1;
100523 }
100524
100525 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100526     return (Dali::BaseHandle *)jarg1;
100527 }
100528
100529 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100530     return (Dali::BaseHandle *)jarg1;
100531 }
100532
100533 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100534     return (Dali::BaseHandle *)jarg1;
100535 }
100536
100537 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100538     return (Dali::CustomActorImpl *)jarg1;
100539 }
100540
100541 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100542     return (Dali::CustomActor *)jarg1;
100543 }
100544
100545 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100546     return (Dali::BaseHandle *)jarg1;
100547 }
100548
100549 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100550     return (Dali::Toolkit::Control *)jarg1;
100551 }
100552
100553 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100554     return (Dali::Toolkit::Control *)jarg1;
100555 }
100556
100557 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100558     return (Dali::Toolkit::Button *)jarg1;
100559 }
100560
100561 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100562     return (Dali::Toolkit::Button *)jarg1;
100563 }
100564
100565 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100566     return (Dali::Toolkit::Button *)jarg1;
100567 }
100568
100569 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100570     return (Dali::Toolkit::Control *)jarg1;
100571 }
100572
100573 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100574     return (Dali::Toolkit::Control *)jarg1;
100575 }
100576
100577 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100578     return (Dali::Toolkit::Control *)jarg1;
100579 }
100580
100581 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100582     return (Dali::Toolkit::Control *)jarg1;
100583 }
100584
100585 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100586     return (Dali::Toolkit::Control *)jarg1;
100587 }
100588
100589 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100590     return (Dali::RefObject *)jarg1;
100591 }
100592
100593 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100594     return (Dali::Toolkit::Scrollable *)jarg1;
100595 }
100596
100597 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100598     return (Dali::BaseHandle *)jarg1;
100599 }
100600
100601 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100602     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100603 }
100604
100605 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100606     return (Dali::RefObject *)jarg1;
100607 }
100608
100609 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100610     return (Dali::Toolkit::Ruler *)jarg1;
100611 }
100612
100613 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100614     return (Dali::Toolkit::Ruler *)jarg1;
100615 }
100616
100617 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100618     return (Dali::Toolkit::Scrollable *)jarg1;
100619 }
100620
100621 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100622     return (Dali::Toolkit::Control *)jarg1;
100623 }
100624
100625
100626 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100627     return (Dali::Toolkit::Control *)jarg1;
100628 }
100629
100630 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
100631     return (Dali::BaseHandle *)jarg1;
100632 }
100633
100634 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
100635     return (Dali::BaseHandle *)jarg1;
100636 }
100637
100638 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
100639     return (Dali::Toolkit::Control *)jarg1;
100640 }
100641
100642 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
100643     return (Dali::Toolkit::Control *)jarg1;
100644 }
100645
100646 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
100647     return (Dali::Toolkit::Control *)jarg1;
100648 }
100649
100650 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
100651     return (Dali::Toolkit::Control *)jarg1;
100652 }
100653
100654 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
100655     return (Dali::Toolkit::Control *)jarg1;
100656 }
100657
100658 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
100659     return (Dali::Toolkit::Control *)jarg1;
100660 }
100661
100662 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
100663     return (Dali::Toolkit::PageTurnView *)jarg1;
100664 }
100665
100666 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
100667     return (Dali::Toolkit::PageTurnView *)jarg1;
100668 }
100669
100670 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
100671     return (Dali::Toolkit::Button *)jarg1;
100672 }
100673
100674 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
100675     return (Dali::BaseHandle *)jarg1;
100676 }
100677
100678 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
100679     return (Dali::BaseHandle *)jarg1;
100680 }
100681
100682 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
100683     return (Dali::BaseHandle *)jarg1;
100684 }
100685
100686 /*
100687  * Widget binding
100688  */
100689 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
100690     return (Dali::BaseHandle *)jarg1;
100691 }
100692
100693 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
100694     return (Dali::BaseObject *)jarg1;
100695 }
100696
100697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
100698   void * jresult ;
100699   Dali::Widget result;
100700
100701   {
100702     try {
100703       result = Dali::Widget::New();
100704     } catch (std::out_of_range& e) {
100705       {
100706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100707       };
100708     } catch (std::exception& e) {
100709       {
100710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100711       };
100712     } catch (...) {
100713       {
100714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100715       };
100716     }
100717   }
100718   jresult = new Dali::Widget((const Dali::Widget &)result);
100719   return jresult;
100720 }
100721
100722
100723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
100724   void * jresult ;
100725   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
100726   Dali::Widget result;
100727
100728   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100729
100730   if (!arg1) {
100731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100732     return 0;
100733   }
100734   {
100735     try {
100736       jresult = new Dali::Widget(arg1);
100737     } catch (std::out_of_range& e) {
100738       {
100739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100740       };
100741     } catch (std::exception& e) {
100742       {
100743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100744       };
100745     } catch (...) {
100746       {
100747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100748       };
100749     }
100750   }
100751   return jresult;
100752 }
100753
100754
100755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100756   void * jresult ;
100757   Dali::Widget *result = 0 ;
100758
100759   {
100760     try {
100761       result = (Dali::Widget *)new Dali::Widget();
100762     } catch (std::out_of_range& e) {
100763       {
100764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100765       };
100766     } catch (std::exception& e) {
100767       {
100768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100769       };
100770     } catch (...) {
100771       {
100772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100773       };
100774     }
100775   }
100776   jresult = (void *)result;
100777   return jresult;
100778 }
100779
100780
100781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100782   void * jresult ;
100783   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100784   Dali::Widget *arg2 = 0 ;
100785   Dali::Widget *result = 0 ;
100786
100787   arg1 = (Dali::Widget *)jarg1;
100788   arg2 = (Dali::Widget *)jarg2;
100789   if (!arg2) {
100790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100791     return 0;
100792   }
100793   {
100794     try {
100795       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100796     } catch (std::out_of_range& e) {
100797       {
100798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100799       };
100800     } catch (std::exception& e) {
100801       {
100802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100803       };
100804     } catch (...) {
100805       {
100806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100807       };
100808     }
100809   }
100810   jresult = (void *)result;
100811   return jresult;
100812 }
100813
100814
100815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100816   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100817
100818   arg1 = (Dali::Widget *)jarg1;
100819   {
100820     try {
100821       delete arg1;
100822     } catch (std::out_of_range& e) {
100823       {
100824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100825       };
100826     } catch (std::exception& e) {
100827       {
100828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100829       };
100830     } catch (...) {
100831       {
100832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100833       };
100834     }
100835   }
100836 }
100837
100838
100839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100840   void * jresult ;
100841   SwigDirector_WidgetImpl* result;
100842   {
100843     try {
100844       result = new SwigDirector_WidgetImpl();
100845     } catch (std::out_of_range& e) {
100846       {
100847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100848       };
100849     } catch (std::exception& e) {
100850       {
100851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100852       };
100853     } catch (...) {
100854       {
100855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100856       };
100857     }
100858   }
100859   jresult = result;
100860   return jresult;
100861 }
100862
100863
100864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100865   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100866   std::string *arg2 = 0 ;
100867   Dali::Window arg3 ;
100868   Dali::Window *argp3 ;
100869
100870   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100871   if (!jarg2) {
100872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100873     return ;
100874   }
100875   std::string arg2_str(jarg2);
100876   arg2 = &arg2_str;
100877   argp3 = (Dali::Window *)jarg3;
100878   if (!argp3) {
100879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100880     return ;
100881   }
100882   arg3 = *argp3;
100883   {
100884     try {
100885       (arg1)->OnCreate((std::string const &)*arg2,arg3);
100886     } catch (std::out_of_range& e) {
100887       {
100888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100889       };
100890     } catch (std::exception& e) {
100891       {
100892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100893       };
100894     } catch (...) {
100895       {
100896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100897       };
100898     }
100899   }
100900 }
100901
100902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100903   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100904   std::string *arg2 = 0 ;
100905   Dali::Window arg3 ;
100906   Dali::Window *argp3 ;
100907
100908   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100909   if (!jarg2) {
100910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100911     return ;
100912   }
100913   std::string arg2_str(jarg2);
100914   arg2 = &arg2_str;
100915   argp3 = (Dali::Window *)jarg3;
100916   if (!argp3) {
100917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100918     return ;
100919   }
100920   arg3 = *argp3;
100921   {
100922     try {
100923       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100924     } catch (std::out_of_range& e) {
100925       {
100926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100927       };
100928     } catch (std::exception& e) {
100929       {
100930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100931       };
100932     } catch (...) {
100933       {
100934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100935       };
100936     }
100937   }
100938 }
100939
100940
100941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100942   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100943   std::string *arg2 = 0 ;
100944   Dali::Widget::Termination arg3 ;
100945
100946   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100947   if (!jarg2) {
100948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100949     return ;
100950   }
100951   std::string arg2_str(jarg2);
100952   arg2 = &arg2_str;
100953   arg3 = (Dali::Widget::Termination)jarg3;
100954   {
100955     try {
100956       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100957     } catch (std::out_of_range& e) {
100958       {
100959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100960       };
100961     } catch (std::exception& e) {
100962       {
100963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100964       };
100965     } catch (...) {
100966       {
100967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100968       };
100969     }
100970   }
100971 }
100972
100973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100974   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100975   std::string *arg2 = 0 ;
100976   Dali::Widget::Termination arg3 ;
100977
100978   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100979   if (!jarg2) {
100980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100981     return ;
100982   }
100983   std::string arg2_str(jarg2);
100984   arg2 = &arg2_str;
100985   arg3 = (Dali::Widget::Termination)jarg3;
100986   {
100987     try {
100988       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
100989     } catch (std::out_of_range& e) {
100990       {
100991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100992       };
100993     } catch (std::exception& e) {
100994       {
100995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100996       };
100997     } catch (...) {
100998       {
100999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101000       };
101001     }
101002   }
101003 }
101004
101005
101006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
101007   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101008
101009   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101010   {
101011     try {
101012       (arg1)->OnPause();
101013     } catch (std::out_of_range& e) {
101014       {
101015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101016       };
101017     } catch (std::exception& e) {
101018       {
101019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101020       };
101021     } catch (...) {
101022       {
101023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101024       };
101025     }
101026   }
101027 }
101028
101029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
101030   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101031
101032   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101033   {
101034     try {
101035       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101036     } catch (std::out_of_range& e) {
101037       {
101038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101039       };
101040     } catch (std::exception& e) {
101041       {
101042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101043       };
101044     } catch (...) {
101045       {
101046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101047       };
101048     }
101049   }
101050 }
101051
101052
101053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101054   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101055
101056   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101057   {
101058     try {
101059       (arg1)->OnResume();
101060     } catch (std::out_of_range& e) {
101061       {
101062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101063       };
101064     } catch (std::exception& e) {
101065       {
101066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101067       };
101068     } catch (...) {
101069       {
101070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101071       };
101072     }
101073   }
101074 }
101075
101076
101077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101078   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101079
101080   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101081   {
101082     try {
101083       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101084     } catch (std::out_of_range& e) {
101085       {
101086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101087       };
101088     } catch (std::exception& e) {
101089       {
101090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101091       };
101092     } catch (...) {
101093       {
101094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101095       };
101096     }
101097   }
101098 }
101099
101100
101101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101102   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101103   Dali::Window arg2 ;
101104   Dali::Window *argp2 ;
101105
101106   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101107   argp2 = (Dali::Window *)jarg2;
101108   if (!argp2) {
101109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101110     return ;
101111   }
101112   arg2 = *argp2;
101113   {
101114     try {
101115       (arg1)->OnResize(arg2);
101116     } catch (std::out_of_range& e) {
101117       {
101118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101119       };
101120     } catch (std::exception& e) {
101121       {
101122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101123       };
101124     } catch (...) {
101125       {
101126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101127       };
101128     }
101129   }
101130 }
101131
101132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101133   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101134   Dali::Window arg2 ;
101135   Dali::Window *argp2 ;
101136
101137   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101138   argp2 = (Dali::Window *)jarg2;
101139   if (!argp2) {
101140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101141     return ;
101142   }
101143   arg2 = *argp2;
101144   {
101145     try {
101146       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101147     } catch (std::out_of_range& e) {
101148       {
101149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101150       };
101151     } catch (std::exception& e) {
101152       {
101153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101154       };
101155     } catch (...) {
101156       {
101157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101158       };
101159     }
101160   }
101161 }
101162
101163
101164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101165   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101166   std::string *arg2 = 0 ;
101167   int arg3 ;
101168
101169   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101170   if (!jarg2) {
101171     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101172     return ;
101173   }
101174   std::string arg2_str(jarg2);
101175   arg2 = &arg2_str;
101176   arg3 = (int)jarg3;
101177   {
101178     try {
101179       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101180     } catch (std::out_of_range& e) {
101181       {
101182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101183       };
101184     } catch (std::exception& e) {
101185       {
101186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101187       };
101188     } catch (...) {
101189       {
101190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101191       };
101192     }
101193   }
101194 }
101195
101196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101197   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101198   std::string *arg2 = 0 ;
101199   int arg3 ;
101200
101201   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101202   if (!jarg2) {
101203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101204     return ;
101205   }
101206   std::string arg2_str(jarg2);
101207   arg2 = &arg2_str;
101208   arg3 = (int)jarg3;
101209   {
101210     try {
101211       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101212     } catch (std::out_of_range& e) {
101213       {
101214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101215       };
101216     } catch (std::exception& e) {
101217       {
101218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101219       };
101220     } catch (...) {
101221       {
101222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101223       };
101224     }
101225   }
101226 }
101227
101228
101229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101230   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101231   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101232   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101233
101234   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101235   arg2 = (Dali::SlotObserver *)jarg2;
101236   arg3 = (Dali::CallbackBase *)jarg3;
101237   {
101238     try {
101239       (arg1)->SignalConnected(arg2,arg3);
101240     } catch (std::out_of_range& e) {
101241       {
101242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101243       };
101244     } catch (std::exception& e) {
101245       {
101246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101247       };
101248     } catch (...) {
101249       {
101250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101251       };
101252     }
101253   }
101254 }
101255
101256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101257   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101258   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101259   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101260
101261   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101262   arg2 = (Dali::SlotObserver *)jarg2;
101263   arg3 = (Dali::CallbackBase *)jarg3;
101264   {
101265     try {
101266       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101267     } catch (std::out_of_range& e) {
101268       {
101269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101270       };
101271     } catch (std::exception& e) {
101272       {
101273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101274       };
101275     } catch (...) {
101276       {
101277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101278       };
101279     }
101280   }
101281 }
101282
101283
101284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101285   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101286   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101287   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101288
101289   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101290   arg2 = (Dali::SlotObserver *)jarg2;
101291   arg3 = (Dali::CallbackBase *)jarg3;
101292   {
101293     try {
101294       (arg1)->SignalDisconnected(arg2,arg3);
101295     } catch (std::out_of_range& e) {
101296       {
101297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101298       };
101299     } catch (std::exception& e) {
101300       {
101301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101302       };
101303     } catch (...) {
101304       {
101305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101306       };
101307     }
101308   }
101309 }
101310
101311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101312   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101313   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101314   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101315
101316   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101317   arg2 = (Dali::SlotObserver *)jarg2;
101318   arg3 = (Dali::CallbackBase *)jarg3;
101319   {
101320     try {
101321       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101322     } catch (std::out_of_range& e) {
101323       {
101324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101325       };
101326     } catch (std::exception& e) {
101327       {
101328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101329       };
101330     } catch (...) {
101331       {
101332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101333       };
101334     }
101335   }
101336 }
101337
101338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101339   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101340   std::string *arg2 = 0 ;
101341
101342   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101343   if (!jarg2) {
101344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101345     return ;
101346   }
101347   std::string arg2_str(jarg2);
101348   arg2 = &arg2_str;
101349   {
101350     try {
101351       (arg1)->SetContentInfo((std::string const &)*arg2);
101352     } catch (std::out_of_range& e) {
101353       {
101354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101355       };
101356     } catch (std::exception& e) {
101357       {
101358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101359       };
101360     } catch (...) {
101361       {
101362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101363       };
101364     }
101365   }
101366 }
101367
101368
101369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101370   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101371   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101372
101373   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101374   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101375   {
101376     try {
101377       (arg1)->SetImpl(arg2);
101378     } catch (std::out_of_range& e) {
101379       {
101380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101381       };
101382     } catch (std::exception& e) {
101383       {
101384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101385       };
101386     } catch (...) {
101387       {
101388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101389       };
101390     }
101391   }
101392 }
101393
101394 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) {
101395
101396   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101397   if (director) {
101398     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101399   }
101400 }
101401
101402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101403   void * jresult ;
101404   Dali::Widget *arg1 = 0 ;
101405   SwigDirector_WidgetImpl *result = 0 ;
101406
101407   arg1 = (Dali::Widget *)jarg1;
101408   if (!arg1) {
101409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101410     return 0;
101411   }
101412   {
101413     try {
101414       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
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
101430   jresult = (void *)result;
101431   return jresult;
101432 }
101433
101434
101435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101436   void * jresult ;
101437   int *arg1 = (int *) 0 ;
101438   char ***arg2 ;
101439   std::string *arg3 = 0 ;
101440   Dali::WidgetApplication result;
101441   {
101442     int index = 0;
101443     int length = 0;
101444     char *retPtr;
101445     char *nextPtr;
101446     argWidgetC = jarg1;
101447     argWidgetV = new char*[jarg1 + 1];
101448
101449     retPtr = strtok_r( jarg2, " ", &nextPtr);
101450     if( retPtr )
101451     {
101452       length = strlen(retPtr);
101453     }
101454     argWidgetV[index] = new char[length + 1];
101455     if( retPtr )
101456     {
101457       strncpy(argWidgetV[index], retPtr, length);
101458     }
101459     argWidgetV[index][length] = '\0';
101460     index++;
101461
101462     while (index < jarg1)
101463     {
101464       length = 0;
101465       retPtr = strtok_r(NULL, " ", &nextPtr);
101466       if( retPtr )
101467       {
101468         length = strlen(retPtr);
101469       }
101470       argWidgetV[index] = new char[length + 1];
101471       if( retPtr )
101472       {
101473         strncpy(argWidgetV[index], retPtr, length);
101474       }
101475       argWidgetV[index][length] = '\0';
101476       index++;
101477     }
101478
101479     argWidgetV[jarg1] = NULL;
101480     argWidgetC = jarg1;
101481
101482     arg1 = &argWidgetC;
101483     arg2 = &argWidgetV;
101484   }
101485
101486   if (!jarg3) {
101487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101488     return 0;
101489   }
101490   std::string arg3_str(jarg3);
101491   arg3 = &arg3_str;
101492   {
101493     try {
101494       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
101495     } catch (std::out_of_range& e) {
101496       {
101497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101498       };
101499     } catch (std::exception& e) {
101500       {
101501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101502       };
101503     } catch (...) {
101504       {
101505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101506       };
101507     }
101508   }
101509   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
101510
101511   return jresult;
101512 }
101513
101514
101515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101516   void * jresult ;
101517   Dali::WidgetApplication *result = 0 ;
101518
101519   {
101520     try {
101521       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101522     } catch (std::out_of_range& e) {
101523       {
101524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101525       };
101526     } catch (std::exception& e) {
101527       {
101528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101529       };
101530     } catch (...) {
101531       {
101532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101533       };
101534     }
101535   }
101536   jresult = (void *)result;
101537   return jresult;
101538 }
101539
101540
101541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101542   void * jresult ;
101543   Dali::WidgetApplication *arg1 = 0 ;
101544   Dali::WidgetApplication *result = 0 ;
101545
101546   arg1 = (Dali::WidgetApplication *)jarg1;
101547   if (!arg1) {
101548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101549     return 0;
101550   }
101551   {
101552     try {
101553       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101554     } catch (std::out_of_range& e) {
101555       {
101556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101557       };
101558     } catch (std::exception& e) {
101559       {
101560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101561       };
101562     } catch (...) {
101563       {
101564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101565       };
101566     }
101567   }
101568   jresult = (void *)result;
101569   return jresult;
101570 }
101571
101572
101573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
101574   void * jresult ;
101575   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101576   Dali::WidgetApplication *arg2 = 0 ;
101577   Dali::WidgetApplication *result = 0 ;
101578
101579   arg1 = (Dali::WidgetApplication *)jarg1;
101580   arg2 = (Dali::WidgetApplication *)jarg2;
101581   if (!arg2) {
101582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101583     return 0;
101584   }
101585   {
101586     try {
101587       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
101588     } catch (std::out_of_range& e) {
101589       {
101590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101591       };
101592     } catch (std::exception& e) {
101593       {
101594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101595       };
101596     } catch (...) {
101597       {
101598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101599       };
101600     }
101601   }
101602   jresult = (void *)result;
101603   return jresult;
101604 }
101605
101606
101607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
101608   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101609
101610   arg1 = (Dali::WidgetApplication *)jarg1;
101611   {
101612     try {
101613       delete arg1;
101614       if( argWidgetV )
101615       {
101616         // free string data
101617         for( int i=0; i < argWidgetC+1; i++)
101618         {
101619           delete [] argWidgetV[i];
101620         }
101621         delete [] argWidgetV;
101622       }
101623     } catch (std::out_of_range& e) {
101624       {
101625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101626       };
101627     } catch (std::exception& e) {
101628       {
101629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101630       };
101631     } catch (...) {
101632       {
101633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101634       };
101635     }
101636   }
101637 }
101638
101639
101640 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
101641 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
101642
101643 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
101644 {
101645   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
101646   return *widget;
101647 }
101648
101649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
101650   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101651   std::string *arg2 = 0 ;
101652
101653   arg1 = (Dali::WidgetApplication *)jarg1;
101654   if (!jarg2) {
101655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101656     return ;
101657   }
101658   std::string arg2_str(*jarg2);
101659   arg2 = &arg2_str;
101660
101661   if(!_CSharpCreateWidgetFunction)
101662   {
101663     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
101664   }
101665
101666   {
101667     try {
101668       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
101669     } catch (std::out_of_range& e) {
101670       {
101671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101672       };
101673     } catch (std::exception& e) {
101674       {
101675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101676       };
101677     } catch (...) {
101678       {
101679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101680       };
101681     }
101682   }
101683
101684   //Typemap argout in c++ file.
101685   //This will convert c++ string to c# string
101686   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
101687 }
101688
101689
101690 //for PixelBuffer and ImageLoading
101691
101692 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101693     return (Dali::BaseHandle *)jarg1;
101694 }
101695
101696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101697   void * jresult ;
101698   unsigned int arg1 ;
101699   unsigned int arg2 ;
101700   Dali::Pixel::Format arg3 ;
101701   Dali::Devel::PixelBuffer result;
101702
101703   arg1 = (unsigned int)jarg1;
101704   arg2 = (unsigned int)jarg2;
101705   arg3 = (Dali::Pixel::Format)jarg3;
101706   {
101707     try {
101708       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
101709     } catch (std::out_of_range& e) {
101710       {
101711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101712       };
101713     } catch (std::exception& e) {
101714       {
101715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101716       };
101717     } catch (...) {
101718       {
101719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101720       };
101721     }
101722   }
101723   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101724   return jresult;
101725 }
101726
101727
101728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101729   void * jresult ;
101730   Dali::Devel::PixelBuffer *result = 0 ;
101731
101732   {
101733     try {
101734       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101735     } catch (std::out_of_range& e) {
101736       {
101737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101738       };
101739     } catch (std::exception& e) {
101740       {
101741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101742       };
101743     } catch (...) {
101744       {
101745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101746       };
101747     }
101748   }
101749   jresult = (void *)result;
101750   return jresult;
101751 }
101752
101753
101754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101755   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101756
101757   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101758   {
101759     try {
101760       delete arg1;
101761     } catch (std::out_of_range& e) {
101762       {
101763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101764       };
101765     } catch (std::exception& e) {
101766       {
101767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101768       };
101769     } catch (...) {
101770       {
101771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101772       };
101773     }
101774   }
101775 }
101776
101777
101778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101779   void * jresult ;
101780   Dali::Devel::PixelBuffer *arg1 = 0 ;
101781   Dali::Devel::PixelBuffer *result = 0 ;
101782
101783   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101784   if (!arg1) {
101785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101786     return 0;
101787   }
101788   {
101789     try {
101790       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101791     } catch (std::out_of_range& e) {
101792       {
101793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101794       };
101795     } catch (std::exception& e) {
101796       {
101797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101798       };
101799     } catch (...) {
101800       {
101801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101802       };
101803     }
101804   }
101805   jresult = (void *)result;
101806   return jresult;
101807 }
101808
101809
101810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101811   void * jresult ;
101812   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101813   Dali::Devel::PixelBuffer *arg2 = 0 ;
101814   Dali::Devel::PixelBuffer *result = 0 ;
101815
101816   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101817   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101818   if (!arg2) {
101819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101820     return 0;
101821   }
101822   {
101823     try {
101824       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101825     } catch (std::out_of_range& e) {
101826       {
101827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101828       };
101829     } catch (std::exception& e) {
101830       {
101831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101832       };
101833     } catch (...) {
101834       {
101835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101836       };
101837     }
101838   }
101839   jresult = (void *)result;
101840   return jresult;
101841 }
101842
101843
101844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101845   void * jresult ;
101846   Dali::Devel::PixelBuffer *arg1 = 0 ;
101847   Dali::PixelData result;
101848
101849   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101850   if (!arg1) {
101851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101852     return 0;
101853   }
101854   {
101855     try {
101856       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101857     } catch (std::out_of_range& e) {
101858       {
101859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101860       };
101861     } catch (std::exception& e) {
101862       {
101863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101864       };
101865     } catch (...) {
101866       {
101867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101868       };
101869     }
101870   }
101871   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101872   return jresult;
101873 }
101874
101875
101876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101877   void * jresult ;
101878   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101879   Dali::PixelData result;
101880
101881   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101882   {
101883     try {
101884       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101885     } catch (std::out_of_range& e) {
101886       {
101887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101888       };
101889     } catch (std::exception& e) {
101890       {
101891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101892       };
101893     } catch (...) {
101894       {
101895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101896       };
101897     }
101898   }
101899   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101900   return jresult;
101901 }
101902
101903
101904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101905   void * jresult ;
101906   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101907   unsigned char *result = 0 ;
101908
101909   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101910   {
101911     try {
101912       result = (unsigned char *)(arg1)->GetBuffer();
101913     } catch (std::out_of_range& e) {
101914       {
101915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101916       };
101917     } catch (std::exception& e) {
101918       {
101919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101920       };
101921     } catch (...) {
101922       {
101923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101924       };
101925     }
101926   }
101927   jresult = (void *)result;
101928   return jresult;
101929 }
101930
101931
101932 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101933   unsigned int jresult ;
101934   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101935   unsigned int result;
101936
101937   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101938   {
101939     try {
101940       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101941     } catch (std::out_of_range& e) {
101942       {
101943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101944       };
101945     } catch (std::exception& e) {
101946       {
101947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101948       };
101949     } catch (...) {
101950       {
101951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101952       };
101953     }
101954   }
101955   jresult = result;
101956   return jresult;
101957 }
101958
101959
101960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101961   unsigned int jresult ;
101962   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101963   unsigned int result;
101964
101965   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101966   {
101967     try {
101968       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101969     } catch (std::out_of_range& e) {
101970       {
101971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101972       };
101973     } catch (std::exception& e) {
101974       {
101975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101976       };
101977     } catch (...) {
101978       {
101979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101980       };
101981     }
101982   }
101983   jresult = result;
101984   return jresult;
101985 }
101986
101987
101988 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101989   int jresult ;
101990   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101991   Dali::Pixel::Format result;
101992
101993   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101994   {
101995     try {
101996       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101997     } catch (std::out_of_range& e) {
101998       {
101999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102000       };
102001     } catch (std::exception& e) {
102002       {
102003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102004       };
102005     } catch (...) {
102006       {
102007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102008       };
102009     }
102010   }
102011   jresult = (int)result;
102012   return jresult;
102013 }
102014
102015
102016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
102017   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102018   Dali::Devel::PixelBuffer arg2 ;
102019   float arg3 ;
102020   bool arg4 ;
102021   Dali::Devel::PixelBuffer *argp2 ;
102022
102023   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102024   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102025   if (!argp2) {
102026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102027     return ;
102028   }
102029   arg2 = *argp2;
102030   arg3 = (float)jarg3;
102031   arg4 = jarg4 ? true : false;
102032   {
102033     try {
102034       (arg1)->ApplyMask(arg2,arg3,arg4);
102035     } catch (std::out_of_range& e) {
102036       {
102037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102038       };
102039     } catch (std::exception& e) {
102040       {
102041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102042       };
102043     } catch (...) {
102044       {
102045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102046       };
102047     }
102048   }
102049 }
102050
102051
102052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102053   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102054   Dali::Devel::PixelBuffer arg2 ;
102055   float arg3 ;
102056   Dali::Devel::PixelBuffer *argp2 ;
102057
102058   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102059   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102060   if (!argp2) {
102061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102062     return ;
102063   }
102064   arg2 = *argp2;
102065   arg3 = (float)jarg3;
102066   {
102067     try {
102068       (arg1)->ApplyMask(arg2,arg3);
102069     } catch (std::out_of_range& e) {
102070       {
102071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102072       };
102073     } catch (std::exception& e) {
102074       {
102075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102076       };
102077     } catch (...) {
102078       {
102079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102080       };
102081     }
102082   }
102083 }
102084
102085
102086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102087   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102088   Dali::Devel::PixelBuffer arg2 ;
102089   Dali::Devel::PixelBuffer *argp2 ;
102090
102091   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102092   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102093   if (!argp2) {
102094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102095     return ;
102096   }
102097   arg2 = *argp2;
102098   {
102099     try {
102100       (arg1)->ApplyMask(arg2);
102101     } catch (std::out_of_range& e) {
102102       {
102103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102104       };
102105     } catch (std::exception& e) {
102106       {
102107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102108       };
102109     } catch (...) {
102110       {
102111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102112       };
102113     }
102114   }
102115 }
102116
102117
102118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102119   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102120   float arg2 ;
102121
102122   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102123   arg2 = (float)jarg2;
102124   {
102125     try {
102126       (arg1)->ApplyGaussianBlur(arg2);
102127     } catch (std::out_of_range& e) {
102128       {
102129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102130       };
102131     } catch (std::exception& e) {
102132       {
102133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102134       };
102135     } catch (...) {
102136       {
102137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102138       };
102139     }
102140   }
102141 }
102142
102143
102144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102145   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102146   uint16_t arg2 ;
102147   uint16_t arg3 ;
102148   uint16_t arg4 ;
102149   uint16_t arg5 ;
102150
102151   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102152   arg2 = (uint16_t)jarg2;
102153   arg3 = (uint16_t)jarg3;
102154   arg4 = (uint16_t)jarg4;
102155   arg5 = (uint16_t)jarg5;
102156   {
102157     try {
102158       (arg1)->Crop(arg2,arg3,arg4,arg5);
102159     } catch (std::out_of_range& e) {
102160       {
102161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102162       };
102163     } catch (std::exception& e) {
102164       {
102165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102166       };
102167     } catch (...) {
102168       {
102169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102170       };
102171     }
102172   }
102173 }
102174
102175
102176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102177   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102178   uint16_t arg2 ;
102179   uint16_t arg3 ;
102180
102181   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102182   arg2 = (uint16_t)jarg2;
102183   arg3 = (uint16_t)jarg3;
102184   {
102185     try {
102186       (arg1)->Resize(arg2,arg3);
102187     } catch (std::out_of_range& e) {
102188       {
102189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102190       };
102191     } catch (std::exception& e) {
102192       {
102193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102194       };
102195     } catch (...) {
102196       {
102197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102198       };
102199     }
102200   }
102201 }
102202
102203
102204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102205   void * jresult ;
102206   std::string *arg1 = 0 ;
102207   Dali::ImageDimensions arg2 ;
102208   Dali::FittingMode::Type arg3 ;
102209   Dali::SamplingMode::Type arg4 ;
102210   bool arg5 ;
102211   Dali::ImageDimensions *argp2 ;
102212   Dali::Devel::PixelBuffer result;
102213
102214   if (!jarg1) {
102215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102216     return 0;
102217   }
102218   std::string arg1_str(jarg1);
102219   arg1 = &arg1_str;
102220   argp2 = (Dali::ImageDimensions *)jarg2;
102221   if (!argp2) {
102222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102223     return 0;
102224   }
102225   arg2 = *argp2;
102226   arg3 = (Dali::FittingMode::Type)jarg3;
102227   arg4 = (Dali::SamplingMode::Type)jarg4;
102228   arg5 = jarg5 ? true : false;
102229   {
102230     try {
102231       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102232     } catch (std::out_of_range& e) {
102233       {
102234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102235       };
102236     } catch (std::exception& e) {
102237       {
102238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102239       };
102240     } catch (...) {
102241       {
102242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102243       };
102244     }
102245   }
102246   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102247
102248   return jresult;
102249 }
102250
102251
102252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102253   void * jresult ;
102254   std::string *arg1 = 0 ;
102255   Dali::ImageDimensions arg2 ;
102256   Dali::FittingMode::Type arg3 ;
102257   Dali::SamplingMode::Type arg4 ;
102258   Dali::ImageDimensions *argp2 ;
102259   Dali::Devel::PixelBuffer result;
102260
102261   if (!jarg1) {
102262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102263     return 0;
102264   }
102265   std::string arg1_str(jarg1);
102266   arg1 = &arg1_str;
102267   argp2 = (Dali::ImageDimensions *)jarg2;
102268   if (!argp2) {
102269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102270     return 0;
102271   }
102272   arg2 = *argp2;
102273   arg3 = (Dali::FittingMode::Type)jarg3;
102274   arg4 = (Dali::SamplingMode::Type)jarg4;
102275   {
102276     try {
102277       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102278     } catch (std::out_of_range& e) {
102279       {
102280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102281       };
102282     } catch (std::exception& e) {
102283       {
102284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102285       };
102286     } catch (...) {
102287       {
102288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102289       };
102290     }
102291   }
102292   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102293
102294   return jresult;
102295 }
102296
102297
102298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102299   void * jresult ;
102300   std::string *arg1 = 0 ;
102301   Dali::ImageDimensions arg2 ;
102302   Dali::FittingMode::Type arg3 ;
102303   Dali::ImageDimensions *argp2 ;
102304   Dali::Devel::PixelBuffer result;
102305
102306   if (!jarg1) {
102307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102308     return 0;
102309   }
102310   std::string arg1_str(jarg1);
102311   arg1 = &arg1_str;
102312   argp2 = (Dali::ImageDimensions *)jarg2;
102313   if (!argp2) {
102314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102315     return 0;
102316   }
102317   arg2 = *argp2;
102318   arg3 = (Dali::FittingMode::Type)jarg3;
102319   {
102320     try {
102321       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102322     } catch (std::out_of_range& e) {
102323       {
102324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102325       };
102326     } catch (std::exception& e) {
102327       {
102328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102329       };
102330     } catch (...) {
102331       {
102332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102333       };
102334     }
102335   }
102336   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102337
102338   return jresult;
102339 }
102340
102341
102342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102343   void * jresult ;
102344   std::string *arg1 = 0 ;
102345   Dali::ImageDimensions arg2 ;
102346   Dali::ImageDimensions *argp2 ;
102347   Dali::Devel::PixelBuffer result;
102348
102349   if (!jarg1) {
102350     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102351     return 0;
102352   }
102353   std::string arg1_str(jarg1);
102354   arg1 = &arg1_str;
102355   argp2 = (Dali::ImageDimensions *)jarg2;
102356   if (!argp2) {
102357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102358     return 0;
102359   }
102360   arg2 = *argp2;
102361   {
102362     try {
102363       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102364     } catch (std::out_of_range& e) {
102365       {
102366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102367       };
102368     } catch (std::exception& e) {
102369       {
102370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102371       };
102372     } catch (...) {
102373       {
102374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102375       };
102376     }
102377   }
102378   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102379
102380   return jresult;
102381 }
102382
102383
102384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102385   void * jresult ;
102386   std::string *arg1 = 0 ;
102387   Dali::Devel::PixelBuffer result;
102388
102389   if (!jarg1) {
102390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102391     return 0;
102392   }
102393   std::string arg1_str(jarg1);
102394   arg1 = &arg1_str;
102395   {
102396     try {
102397       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102398     } catch (std::out_of_range& e) {
102399       {
102400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102401       };
102402     } catch (std::exception& e) {
102403       {
102404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102405       };
102406     } catch (...) {
102407       {
102408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102409       };
102410     }
102411   }
102412   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102413
102414   return jresult;
102415 }
102416
102417
102418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102419   void * jresult ;
102420   std::string *arg1 = 0 ;
102421   Dali::ImageDimensions arg2 ;
102422   Dali::FittingMode::Type arg3 ;
102423   Dali::SamplingMode::Type arg4 ;
102424   bool arg5 ;
102425   Dali::ImageDimensions *argp2 ;
102426   Dali::ImageDimensions result;
102427
102428   if (!jarg1) {
102429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102430     return 0;
102431   }
102432   std::string arg1_str(jarg1);
102433   arg1 = &arg1_str;
102434   argp2 = (Dali::ImageDimensions *)jarg2;
102435   if (!argp2) {
102436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102437     return 0;
102438   }
102439   arg2 = *argp2;
102440   arg3 = (Dali::FittingMode::Type)jarg3;
102441   arg4 = (Dali::SamplingMode::Type)jarg4;
102442   arg5 = jarg5 ? true : false;
102443   {
102444     try {
102445       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
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 = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102461
102462   return jresult;
102463 }
102464
102465
102466 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102467   void * jresult ;
102468   std::string *arg1 = 0 ;
102469   Dali::ImageDimensions arg2 ;
102470   Dali::FittingMode::Type arg3 ;
102471   Dali::SamplingMode::Type arg4 ;
102472   Dali::ImageDimensions *argp2 ;
102473   Dali::ImageDimensions result;
102474
102475   if (!jarg1) {
102476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102477     return 0;
102478   }
102479   std::string arg1_str(jarg1);
102480   arg1 = &arg1_str;
102481   argp2 = (Dali::ImageDimensions *)jarg2;
102482   if (!argp2) {
102483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102484     return 0;
102485   }
102486   arg2 = *argp2;
102487   arg3 = (Dali::FittingMode::Type)jarg3;
102488   arg4 = (Dali::SamplingMode::Type)jarg4;
102489   {
102490     try {
102491       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102492     } catch (std::out_of_range& e) {
102493       {
102494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102495       };
102496     } catch (std::exception& e) {
102497       {
102498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102499       };
102500     } catch (...) {
102501       {
102502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102503       };
102504     }
102505   }
102506   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102507
102508   return jresult;
102509 }
102510
102511
102512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102513   void * jresult ;
102514   std::string *arg1 = 0 ;
102515   Dali::ImageDimensions arg2 ;
102516   Dali::FittingMode::Type arg3 ;
102517   Dali::ImageDimensions *argp2 ;
102518   Dali::ImageDimensions result;
102519
102520   if (!jarg1) {
102521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102522     return 0;
102523   }
102524   std::string arg1_str(jarg1);
102525   arg1 = &arg1_str;
102526   argp2 = (Dali::ImageDimensions *)jarg2;
102527   if (!argp2) {
102528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102529     return 0;
102530   }
102531   arg2 = *argp2;
102532   arg3 = (Dali::FittingMode::Type)jarg3;
102533   {
102534     try {
102535       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
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 = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102551
102552   return jresult;
102553 }
102554
102555
102556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102557   void * jresult ;
102558   std::string *arg1 = 0 ;
102559   Dali::ImageDimensions arg2 ;
102560   Dali::ImageDimensions *argp2 ;
102561   Dali::ImageDimensions result;
102562
102563   if (!jarg1) {
102564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102565     return 0;
102566   }
102567   std::string arg1_str(jarg1);
102568   arg1 = &arg1_str;
102569   argp2 = (Dali::ImageDimensions *)jarg2;
102570   if (!argp2) {
102571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102572     return 0;
102573   }
102574   arg2 = *argp2;
102575   {
102576     try {
102577       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102578     } catch (std::out_of_range& e) {
102579       {
102580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102581       };
102582     } catch (std::exception& e) {
102583       {
102584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102585       };
102586     } catch (...) {
102587       {
102588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102589       };
102590     }
102591   }
102592   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102593
102594   return jresult;
102595 }
102596
102597
102598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102599   void * jresult ;
102600   std::string *arg1 = 0 ;
102601   Dali::ImageDimensions result;
102602
102603   if (!jarg1) {
102604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102605     return 0;
102606   }
102607   std::string arg1_str(jarg1);
102608   arg1 = &arg1_str;
102609   {
102610     try {
102611       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102612     } catch (std::out_of_range& e) {
102613       {
102614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102615       };
102616     } catch (std::exception& e) {
102617       {
102618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102619       };
102620     } catch (...) {
102621       {
102622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102623       };
102624     }
102625   }
102626   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102627
102628   return jresult;
102629 }
102630
102631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
102632   void * jresult ;
102633   std::string *arg1 = 0 ;
102634   Dali::ImageDimensions result;
102635
102636   if (!jarg1) {
102637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102638     return 0;
102639   }
102640   std::string arg1_str(jarg1);
102641   arg1 = &arg1_str;
102642   {
102643     try {
102644       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
102645     } catch (std::out_of_range& e) {
102646       {
102647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102648       };
102649     } catch (std::exception& e) {
102650       {
102651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102652       };
102653     } catch (...) {
102654       {
102655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102656       };
102657     }
102658   }
102659   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102660
102661   return jresult;
102662 }
102663
102664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102665   void * jresult ;
102666   std::string *arg1 = 0 ;
102667   Dali::ImageDimensions arg2 ;
102668   Dali::FittingMode::Type arg3 ;
102669   Dali::SamplingMode::Type arg4 ;
102670   bool arg5 ;
102671   Dali::ImageDimensions *argp2 ;
102672   Dali::Devel::PixelBuffer result;
102673
102674   if (!jarg1) {
102675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102676     return 0;
102677   }
102678   std::string arg1_str(jarg1);
102679   arg1 = &arg1_str;
102680   argp2 = (Dali::ImageDimensions *)jarg2;
102681   if (!argp2) {
102682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102683     return 0;
102684   }
102685   arg2 = *argp2;
102686   arg3 = (Dali::FittingMode::Type)jarg3;
102687   arg4 = (Dali::SamplingMode::Type)jarg4;
102688   arg5 = jarg5 ? true : false;
102689   {
102690     try {
102691       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102692     } catch (std::out_of_range& e) {
102693       {
102694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102695       };
102696     } catch (std::exception& e) {
102697       {
102698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102699       };
102700     } catch (...) {
102701       {
102702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102703       };
102704     }
102705   }
102706   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102707
102708   return jresult;
102709 }
102710
102711
102712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102713   void * jresult ;
102714   std::string *arg1 = 0 ;
102715   Dali::ImageDimensions arg2 ;
102716   Dali::FittingMode::Type arg3 ;
102717   Dali::SamplingMode::Type arg4 ;
102718   Dali::ImageDimensions *argp2 ;
102719   Dali::Devel::PixelBuffer result;
102720
102721   if (!jarg1) {
102722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102723     return 0;
102724   }
102725   std::string arg1_str(jarg1);
102726   arg1 = &arg1_str;
102727   argp2 = (Dali::ImageDimensions *)jarg2;
102728   if (!argp2) {
102729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102730     return 0;
102731   }
102732   arg2 = *argp2;
102733   arg3 = (Dali::FittingMode::Type)jarg3;
102734   arg4 = (Dali::SamplingMode::Type)jarg4;
102735   {
102736     try {
102737       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102738     } catch (std::out_of_range& e) {
102739       {
102740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102741       };
102742     } catch (std::exception& e) {
102743       {
102744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102745       };
102746     } catch (...) {
102747       {
102748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102749       };
102750     }
102751   }
102752   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102753
102754   return jresult;
102755 }
102756
102757
102758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102759   void * jresult ;
102760   std::string *arg1 = 0 ;
102761   Dali::ImageDimensions arg2 ;
102762   Dali::FittingMode::Type arg3 ;
102763   Dali::ImageDimensions *argp2 ;
102764   Dali::Devel::PixelBuffer result;
102765
102766   if (!jarg1) {
102767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102768     return 0;
102769   }
102770   std::string arg1_str(jarg1);
102771   arg1 = &arg1_str;
102772   argp2 = (Dali::ImageDimensions *)jarg2;
102773   if (!argp2) {
102774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102775     return 0;
102776   }
102777   arg2 = *argp2;
102778   arg3 = (Dali::FittingMode::Type)jarg3;
102779   {
102780     try {
102781       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102782     } catch (std::out_of_range& e) {
102783       {
102784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102785       };
102786     } catch (std::exception& e) {
102787       {
102788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102789       };
102790     } catch (...) {
102791       {
102792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102793       };
102794     }
102795   }
102796   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102797
102798   return jresult;
102799 }
102800
102801
102802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102803   void * jresult ;
102804   std::string *arg1 = 0 ;
102805   Dali::ImageDimensions arg2 ;
102806   Dali::ImageDimensions *argp2 ;
102807   Dali::Devel::PixelBuffer result;
102808
102809   if (!jarg1) {
102810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102811     return 0;
102812   }
102813   std::string arg1_str(jarg1);
102814   arg1 = &arg1_str;
102815   argp2 = (Dali::ImageDimensions *)jarg2;
102816   if (!argp2) {
102817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102818     return 0;
102819   }
102820   arg2 = *argp2;
102821   {
102822     try {
102823       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102824     } catch (std::out_of_range& e) {
102825       {
102826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102827       };
102828     } catch (std::exception& e) {
102829       {
102830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102831       };
102832     } catch (...) {
102833       {
102834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102835       };
102836     }
102837   }
102838   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102839
102840   return jresult;
102841 }
102842
102843
102844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102845   void * jresult ;
102846   std::string *arg1 = 0 ;
102847   Dali::Devel::PixelBuffer result;
102848
102849   if (!jarg1) {
102850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102851     return 0;
102852   }
102853   std::string arg1_str(jarg1);
102854   arg1 = &arg1_str;
102855   {
102856     try {
102857       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102858     } catch (std::out_of_range& e) {
102859       {
102860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102861       };
102862     } catch (std::exception& e) {
102863       {
102864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102865       };
102866     } catch (...) {
102867       {
102868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102869       };
102870     }
102871   }
102872   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102873
102874   return jresult;
102875 }
102876
102877
102878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102879   void * jresult ;
102880   Dali::Toolkit::WebView result;
102881
102882   {
102883     try {
102884       result = Dali::Toolkit::WebView::New();
102885     } catch (std::out_of_range& e) {
102886       {
102887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102888       };
102889     } catch (std::exception& e) {
102890       {
102891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102892       };
102893     } catch (Dali::DaliException e) {
102894       {
102895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102896       };
102897     } catch (...) {
102898       {
102899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102900       };
102901     }
102902   }
102903   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102904   return jresult;
102905 }
102906
102907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
102908   void * jresult ;
102909   Dali::Toolkit::WebView result;
102910
102911   std::string *arg1;
102912   std::string *arg2;
102913
102914   if (!jarg1) {
102915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102916     return 0;
102917   }
102918   if (!jarg2) {
102919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102920     return 0;
102921   }
102922
102923   std::string jarg1_str = std::string(jarg1);
102924   std::string jarg2_str = std::string(jarg2);
102925
102926   arg1 = &jarg1_str;
102927   arg2 = &jarg2_str;
102928
102929   {
102930     try {
102931       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102932     } catch (std::out_of_range& e) {
102933       {
102934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102935       };
102936     } catch (std::exception& e) {
102937       {
102938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102939       };
102940     } catch (Dali::DaliException e) {
102941       {
102942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102943       };
102944     } catch (...) {
102945       {
102946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102947       };
102948     }
102949   }
102950   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102951   return jresult;
102952 }
102953
102954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102955   void * jresult ;
102956   Dali::Toolkit::WebView *arg1 = 0 ;
102957   Dali::Toolkit::WebView *result = 0 ;
102958
102959   arg1 = (Dali::Toolkit::WebView *)jarg1;
102960   if (!arg1) {
102961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102962     return 0;
102963   }
102964   {
102965     try {
102966       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
102967     } catch (std::out_of_range& e) {
102968       {
102969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102970       };
102971     } catch (std::exception& e) {
102972       {
102973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102974       };
102975     } catch (Dali::DaliException e) {
102976       {
102977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102978       };
102979     } catch (...) {
102980       {
102981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102982       };
102983     }
102984   }
102985   jresult = (void *)result;
102986   return jresult;
102987 }
102988
102989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102990   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102991   arg1 = (Dali::Toolkit::WebView *)jarg1;
102992   {
102993     try {
102994       delete arg1;
102995     } catch (std::out_of_range& e) {
102996       {
102997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102998       };
102999     } catch (std::exception& e) {
103000       {
103001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103002       };
103003     } catch (Dali::DaliException e) {
103004       {
103005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103006       };
103007     } catch (...) {
103008       {
103009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103010       };
103011     }
103012   }
103013 }
103014
103015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
103016   void * jresult ;
103017   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103018   Dali::Toolkit::WebView *arg2 = 0 ;
103019   Dali::Toolkit::WebView *result = 0 ;
103020
103021   arg1 = (Dali::Toolkit::WebView *)jarg1;
103022   arg2 = (Dali::Toolkit::WebView *)jarg2;
103023   if (!arg2) {
103024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
103025     return 0;
103026   }
103027   {
103028     try {
103029       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
103030     } catch (std::out_of_range& e) {
103031       {
103032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103033       };
103034     } catch (std::exception& e) {
103035       {
103036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103037       };
103038     } catch (Dali::DaliException e) {
103039       {
103040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103041       };
103042     } catch (...) {
103043       {
103044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103045       };
103046     }
103047   }
103048   jresult = (void *)result;
103049   return jresult;
103050 }
103051
103052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103053   void * jresult ;
103054   Dali::BaseHandle arg1 ;
103055   Dali::BaseHandle *argp1 ;
103056   Dali::Toolkit::WebView result;
103057
103058   argp1 = (Dali::BaseHandle *)jarg1;
103059   if (!argp1) {
103060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103061     return 0;
103062   }
103063   arg1 = *argp1;
103064   {
103065     try {
103066       result = Dali::Toolkit::WebView::DownCast(arg1);
103067     } catch (std::out_of_range& e) {
103068       {
103069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103070       };
103071     } catch (std::exception& e) {
103072       {
103073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103074       };
103075     } catch (Dali::DaliException e) {
103076       {
103077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103078       };
103079     } catch (...) {
103080       {
103081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103082       };
103083     }
103084   }
103085   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103086   return jresult;
103087 }
103088
103089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
103090   return (int) Dali::Toolkit::WebView::Property::URL;
103091 }
103092
103093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
103094   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
103095 }
103096
103097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
103098   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
103099 }
103100
103101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
103102   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
103103 }
103104
103105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
103106   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
103107 }
103108
103109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
103110   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
103111 }
103112
103113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
103114   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
103115 }
103116
103117 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
103118   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
103119 }
103120
103121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103122   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103123   std::string *arg2;
103124
103125   arg1 = (Dali::Toolkit::WebView *)jarg1;
103126
103127   if (!jarg2) {
103128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103129     return;
103130   }
103131
103132   std::string jarg2str = std::string(jarg2);
103133   arg2 = &jarg2str;
103134   {
103135     try {
103136       (arg1)->LoadUrl((std::string const &)*arg2);
103137     } catch (std::out_of_range& e) {
103138       {
103139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103140       };
103141     } catch (std::exception& e) {
103142       {
103143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103144       };
103145     } catch (Dali::DaliException e) {
103146       {
103147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103148       };
103149     } catch (...) {
103150       {
103151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103152       };
103153     }
103154   }
103155 }
103156
103157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103158   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103159   std::string *arg2;
103160
103161   arg1 = (Dali::Toolkit::WebView *)jarg1;
103162   if (!jarg2) {
103163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103164     return;
103165   }
103166   std::string jarg2str = std::string(jarg2);
103167   arg2 = &jarg2str;
103168   {
103169     try {
103170       (arg1)->LoadHTMLString((std::string const &)*arg2);
103171     } catch (std::out_of_range& e) {
103172       {
103173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103174       };
103175     } catch (std::exception& e) {
103176       {
103177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103178       };
103179     } catch (Dali::DaliException e) {
103180       {
103181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103182       };
103183     } catch (...) {
103184       {
103185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103186       };
103187     }
103188   }
103189 }
103190
103191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
103192   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103193
103194   arg1 = (Dali::Toolkit::WebView *)jarg1;
103195   {
103196     try {
103197       (arg1)->Reload();
103198     } catch (std::out_of_range& e) {
103199       {
103200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103201       };
103202     } catch (std::exception& e) {
103203       {
103204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103205       };
103206     } catch (Dali::DaliException e) {
103207       {
103208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103209       };
103210     } catch (...) {
103211       {
103212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103213       };
103214     }
103215   }
103216 }
103217
103218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103219   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103220
103221   arg1 = (Dali::Toolkit::WebView *)jarg1;
103222   {
103223     try {
103224       (arg1)->StopLoading();
103225     } catch (std::out_of_range& e) {
103226       {
103227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103228       };
103229     } catch (std::exception& e) {
103230       {
103231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103232       };
103233     } catch (Dali::DaliException e) {
103234       {
103235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103236       };
103237     } catch (...) {
103238       {
103239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103240       };
103241     }
103242   }
103243 }
103244
103245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
103246   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103247
103248   arg1 = (Dali::Toolkit::WebView *)jarg1;
103249   {
103250     try {
103251       (arg1)->Suspend();
103252     } catch (std::out_of_range& e) {
103253       {
103254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103255       };
103256     } catch (std::exception& e) {
103257       {
103258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103259       };
103260     } catch (Dali::DaliException e) {
103261       {
103262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103263       };
103264     } catch (...) {
103265       {
103266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103267       };
103268     }
103269   }
103270 }
103271
103272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
103273   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103274
103275   arg1 = (Dali::Toolkit::WebView *)jarg1;
103276   {
103277     try {
103278       (arg1)->Resume();
103279     } catch (std::out_of_range& e) {
103280       {
103281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103282       };
103283     } catch (std::exception& e) {
103284       {
103285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103286       };
103287     } catch (Dali::DaliException e) {
103288       {
103289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103290       };
103291     } catch (...) {
103292       {
103293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103294       };
103295     }
103296   }
103297 }
103298
103299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103300   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103301
103302   arg1 = (Dali::Toolkit::WebView *)jarg1;
103303   {
103304     try {
103305       (arg1)->GoBack();
103306     } catch (std::out_of_range& e) {
103307       {
103308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103309       };
103310     } catch (std::exception& e) {
103311       {
103312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103313       };
103314     } catch (Dali::DaliException e) {
103315       {
103316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103317       };
103318     } catch (...) {
103319       {
103320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103321       };
103322     }
103323   }
103324 }
103325
103326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103327   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103328
103329   arg1 = (Dali::Toolkit::WebView *)jarg1;
103330   {
103331     try {
103332       (arg1)->GoForward();
103333     } catch (std::out_of_range& e) {
103334       {
103335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103336       };
103337     } catch (std::exception& e) {
103338       {
103339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103340       };
103341     } catch (Dali::DaliException e) {
103342       {
103343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103344       };
103345     } catch (...) {
103346       {
103347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103348       };
103349     }
103350   }
103351 }
103352
103353 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103354   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103355   bool ret;
103356
103357   arg1 = (Dali::Toolkit::WebView *)jarg1;
103358   {
103359     try {
103360       ret = (arg1)->CanGoBack();
103361     } catch (std::out_of_range& e) {
103362       {
103363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103364       };
103365     } catch (std::exception& e) {
103366       {
103367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103368       };
103369     } catch (Dali::DaliException e) {
103370       {
103371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103372       };
103373     } catch (...) {
103374       {
103375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103376       };
103377     }
103378   }
103379   return ret;
103380 }
103381
103382 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103383   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103384   bool ret;
103385
103386   arg1 = (Dali::Toolkit::WebView *)jarg1;
103387   {
103388     try {
103389       ret = (arg1)->CanGoForward();
103390     } catch (std::out_of_range& e) {
103391       {
103392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103393       };
103394     } catch (std::exception& e) {
103395       {
103396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103397       };
103398     } catch (Dali::DaliException e) {
103399       {
103400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103401       };
103402     } catch (...) {
103403       {
103404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103405       };
103406     }
103407   }
103408   return ret;
103409 }
103410
103411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
103412   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103413   std::string *arg2;
103414
103415   arg1 = (Dali::Toolkit::WebView *)jarg1;
103416   if (!jarg2) {
103417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103418     return;
103419   }
103420   std::string jarg2_str = std::string(jarg2);
103421   arg2 = &jarg2_str;
103422
103423   void (*handler)(char*) = (void (*)(char*)) jarg3;
103424
103425   {
103426     try {
103427       (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
103428         handler(SWIG_csharp_string_callback(result.c_str()));
103429       });
103430     } catch (std::out_of_range& e) {
103431       {
103432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103433       };
103434     } catch (std::exception& e) {
103435       {
103436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103437       };
103438     } catch (Dali::DaliException e) {
103439       {
103440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103441       };
103442     } catch (...) {
103443       {
103444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103445       };
103446     }
103447   }
103448 }
103449
103450 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103451 {
103452   if (!jarg2) {
103453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103454     return;
103455   }
103456
103457   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103458   std::string exposedObjectName = jarg2;
103459   void (*handler)(char*) = (void (*)(char*)) jarg3;
103460
103461   {
103462     try {
103463       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103464         handler(SWIG_csharp_string_callback(message.c_str()));
103465       });
103466     } catch (std::out_of_range& e) {
103467       {
103468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103469       };
103470     } catch (std::exception& e) {
103471       {
103472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103473       };
103474     } catch (Dali::DaliException e) {
103475       {
103476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103477       };
103478     } catch (...) {
103479       {
103480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103481       };
103482     }
103483   }
103484 }
103485
103486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103487   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103488
103489   arg1 = (Dali::Toolkit::WebView *)jarg1;
103490   {
103491     try {
103492       (arg1)->ClearHistory();
103493     } catch (std::out_of_range& e) {
103494       {
103495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103496       };
103497     } catch (std::exception& e) {
103498       {
103499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103500       };
103501     } catch (Dali::DaliException e) {
103502       {
103503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103504       };
103505     } catch (...) {
103506       {
103507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103508       };
103509     }
103510   }
103511 }
103512
103513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103514   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103515
103516   arg1 = (Dali::Toolkit::WebView *)jarg1;
103517   {
103518     try {
103519       (arg1)->ClearCache();
103520     } catch (std::out_of_range& e) {
103521       {
103522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103523       };
103524     } catch (std::exception& e) {
103525       {
103526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103527       };
103528     } catch (Dali::DaliException e) {
103529       {
103530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103531       };
103532     } catch (...) {
103533       {
103534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103535       };
103536     }
103537   }
103538 }
103539
103540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
103541   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103542
103543   arg1 = (Dali::Toolkit::WebView *)jarg1;
103544   {
103545     try {
103546       (arg1)->ClearCookies();
103547     } catch (std::out_of_range& e) {
103548       {
103549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103550       };
103551     } catch (std::exception& e) {
103552       {
103553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103554       };
103555     } catch (Dali::DaliException e) {
103556       {
103557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103558       };
103559     } catch (...) {
103560       {
103561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103562       };
103563     }
103564   }
103565 }
103566
103567 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103568     return (Dali::Toolkit::Control *)jarg1;
103569 }
103570
103571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
103572   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103573   SignalConverter::WebViewPageLoadSignal* result = NULL;
103574   {
103575     try {
103576       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
103577     } catch (std::out_of_range& e) {
103578       {
103579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103580       };
103581     } catch (std::exception& e) {
103582       {
103583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103584       };
103585     } catch (Dali::DaliException e) {
103586       {
103587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103588       };
103589     } catch (...) {
103590       {
103591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103592       };
103593     }
103594   }
103595   return (void*) result;
103596 }
103597
103598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
103599   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103600   SignalConverter::WebViewPageLoadSignal* result = NULL;
103601   {
103602     try {
103603       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
103604     } catch (std::out_of_range& e) {
103605       {
103606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103607       };
103608     } catch (std::exception& e) {
103609       {
103610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103611       };
103612     } catch (Dali::DaliException e) {
103613       {
103614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103615       };
103616     } catch (...) {
103617       {
103618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103619       };
103620     }
103621   }
103622   return (void*) result;
103623 }
103624
103625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
103626 {
103627   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103628   {
103629     try {
103630       delete object;
103631     } catch (std::out_of_range& e) {
103632       {
103633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103634       };
103635     } catch (std::exception& e) {
103636       {
103637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103638       };
103639     } catch (Dali::DaliException e) {
103640       {
103641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103642       };
103643     } catch (...) {
103644       {
103645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103646       };
103647     }
103648   }
103649 }
103650
103651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
103652 {
103653   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103654   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103655   {
103656     try {
103657       proxy->Connect(callback);
103658     } catch (std::out_of_range& e) {
103659       {
103660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103661       };
103662     } catch (std::exception& e) {
103663       {
103664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103665       };
103666     } catch (Dali::DaliException e) {
103667       {
103668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103669       };
103670     } catch (...) {
103671       {
103672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103673       };
103674     }
103675   }
103676 }
103677
103678
103679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
103680   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
103681   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
103682   {
103683     try {
103684       proxy->Disconnect(callback);
103685     } catch (std::out_of_range& e) {
103686       {
103687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103688       };
103689     } catch (std::exception& e) {
103690       {
103691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103692       };
103693     } catch (Dali::DaliException e) {
103694       {
103695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103696       };
103697     } catch (...) {
103698       {
103699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103700       };
103701     }
103702   }
103703 }
103704
103705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
103706   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103707   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
103708   {
103709     try {
103710       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
103711     } catch (std::out_of_range& e) {
103712       {
103713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103714       };
103715     } catch (std::exception& e) {
103716       {
103717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103718       };
103719     } catch (Dali::DaliException e) {
103720       {
103721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103722       };
103723     } catch (...) {
103724       {
103725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103726       };
103727     }
103728   }
103729   return (void*) result;
103730 }
103731
103732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
103733 {
103734   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103735   {
103736     try {
103737       delete object;
103738     } catch (std::out_of_range& e) {
103739       {
103740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103741       };
103742     } catch (std::exception& e) {
103743       {
103744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103745       };
103746     } catch (Dali::DaliException e) {
103747       {
103748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103749       };
103750     } catch (...) {
103751       {
103752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103753       };
103754     }
103755   }
103756 }
103757
103758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
103759 {
103760   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103761   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103762   {
103763     try {
103764       proxy->Connect(callback);
103765     } catch (std::out_of_range& e) {
103766       {
103767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103768       };
103769     } catch (std::exception& e) {
103770       {
103771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103772       };
103773     } catch (Dali::DaliException e) {
103774       {
103775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103776       };
103777     } catch (...) {
103778       {
103779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103780       };
103781     }
103782   }
103783 }
103784
103785
103786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
103787   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
103788   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
103789   {
103790     try {
103791       proxy->Disconnect(callback);
103792     } catch (std::out_of_range& e) {
103793       {
103794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103795       };
103796     } catch (std::exception& e) {
103797       {
103798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103799       };
103800     } catch (Dali::DaliException e) {
103801       {
103802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103803       };
103804     } catch (...) {
103805       {
103806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103807       };
103808     }
103809   }
103810 }
103811
103812 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103813   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103814   char * jresult = SWIG_csharp_string_callback((const char *)result);
103815   return jresult;
103816 }
103817
103818 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103819   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103820   return result;
103821 }
103822
103823 #ifdef __cplusplus
103824 }
103825 #endif
103826