dali-csharp-binder/src/dali_wrap.cpp

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 3.0.9
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 289
 290 #ifdef __cplusplus
 291 extern "C"
 292 #endif
 293 SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_NDalic(SWIG_CSharpStringHelperCallback callback) {
 294   SWIG_csharp_string_callback = callback;
 295 }
 296
 297
 298 /* Contract support */
 299
 300 #define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else
 301
 302 /*  Errors in SWIG */
 303 #define  SWIG_UnknownError         -1
 304 #define  SWIG_IOError              -2
 305 #define  SWIG_RuntimeError         -3
 306 #define  SWIG_IndexError           -4
 307 #define  SWIG_TypeError            -5
 308 #define  SWIG_DivisionByZero       -6
 309 #define  SWIG_OverflowError        -7
 310 #define  SWIG_SyntaxError          -8
 311 #define  SWIG_ValueError           -9
 312 #define  SWIG_SystemError          -10
 313 #define  SWIG_AttributeError       -11
 314 #define  SWIG_MemoryError          -12
 315 #define  SWIG_NullReferenceError   -13
 316
 317
 318
 319 /* -----------------------------------------------------------------------------
 320  * director_common.swg
 321  *
 322  * This file contains support for director classes which is common between
 323  * languages.
 324  * ----------------------------------------------------------------------------- */
 325
 326 /*
 327   Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
 328   'Swig' namespace. This could be useful for multi-modules projects.
 329 */
 330 #ifdef SWIG_DIRECTOR_STATIC
 331 /* Force anonymous (static) namespace */
 332 #define Swig
 333 #endif
 334 /* -----------------------------------------------------------------------------
 335  * director.swg
 336  *
 337  * This file contains support for director classes so that C# proxy
 338  * methods can be called from C++.
 339  * ----------------------------------------------------------------------------- */
 340
 341 #if defined(DEBUG_DIRECTOR_OWNED)
 342 #include <iostream>
 343 #endif
 344 #include <string>
 345 #include <exception>
 346
 347 namespace Swig {
 348   /* Director base class - not currently used in C# directors */
 349   class Director {
 350   };
 351
 352   /* Base class for director exceptions */
 353   class DirectorException : public std::exception {
 354   protected:
 355     std::string swig_msg;
 356
 357   public:
 358     DirectorException(const char *msg) : swig_msg(msg) {
 359     }
 360
 361     DirectorException(const std::string &msg) : swig_msg(msg) {
 362     }
 363
 364     virtual ~DirectorException() throw() {
 365     }
 366
 367     const char *what() const throw() {
 368       return swig_msg.c_str();
 369     }
 370   };
 371
 372   /* Pure virtual method exception */
 373   class DirectorPureVirtualException : public DirectorException {
 374   public:
 375     DirectorPureVirtualException(const char *msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
 376     }
 377   };
 378 }
 379
 380
 381 void SWIG_CSharpException(int code, const char *msg) {
 382   if (code == SWIG_ValueError) {
 383     SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
 384     SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
 385   } else {
 386     SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
 387     switch(code) {
 388     case SWIG_MemoryError:
 389       exception_code = SWIG_CSharpOutOfMemoryException;
 390       break;
 391     case SWIG_IndexError:
 392       exception_code = SWIG_CSharpIndexOutOfRangeException;
 393       break;
 394     case SWIG_DivisionByZero:
 395       exception_code = SWIG_CSharpDivideByZeroException;
 396       break;
 397     case SWIG_IOError:
 398       exception_code = SWIG_CSharpIOException;
 399       break;
 400     case SWIG_OverflowError:
 401       exception_code = SWIG_CSharpOverflowException;
 402       break;
 403     case SWIG_RuntimeError:
 404     case SWIG_TypeError:
 405     case SWIG_SyntaxError:
 406     case SWIG_SystemError:
 407     case SWIG_UnknownError:
 408     default:
 409       exception_code = SWIG_CSharpApplicationException;
 410       break;
 411     }
 412     SWIG_CSharpSetPendingException(exception_code, msg);
 413   }
 414 }
 415
 416
 417 #include <stdexcept>
 418
 419
 420 #define SWIGSTDCALL
 421
 422
 423 #include <dali/dali.h>
 424 #include <dali-toolkit/dali-toolkit.h>
 425
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428
 429 #include <dali/public-api/math/matrix.h>
 430 #include <dali/public-api/math/matrix3.h>
 431 #include <dali/public-api/math/viewport.h>
 432 #include <dali/public-api/object/property-key.h>
 433 #include <dali/devel-api/object/csharp-type-info.h>
 434 #include <dali/devel-api/object/csharp-type-registry.h>
 435
 436 #include <dali/public-api/adaptor-framework/timer.h>
 437 #include <dali/public-api/adaptor-framework/style-change.h>
 438 #include <dali/devel-api/adaptor-framework/environment-variable.h>
 439
 440 #include <dali/devel-api/images/nine-patch-image.h>
 441
 442 #include <dali-toolkit/devel-api/builder/builder.h>
 443
 444 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 445 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 446
 447 #include <dali-toolkit/devel-api/controls/control-devel.h>
 448 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 449 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 454 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 455
 456 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 457 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 458 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 459
 460 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 462 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 463
 464 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 465 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 470 #include <dali/devel-api/adaptor-framework/image-loading.h>
 471
 472 #include <dali/public-api/events/mouse-button.h>
 473
 474 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 475
 476
 477 // add here SWIG version check
 478
 479 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 480 // disable Swig-dependent warnings
 481
 482 // 'identifier1' has C-linkage specified,
 483 // but returns UDT 'identifier2' which is incompatible with C
 484 #pragma warning(disable: 4190)
 485
 486 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 487 #pragma warning(disable: 4800)
 488
 489 // debug info too long etc etc
 490 #pragma warning(disable: 4786)
 491 #endif
 492
 493
 494 #include <stdexcept>
 495
 496
 497 #include <string>
 498
 499
 500 #include <vector>
 501 #include <algorithm>
 502 #include <stdexcept>
 503
 504
 505 #include <map>
 506 #include <algorithm>
 507 #include <stdexcept>
 508
 509
 510 #include <utility>
 511
 512
 513 typedef float floatp;
 514
 515 SWIGINTERN floatp *new_floatp(){
 516   return new float();
 517 }
 518 SWIGINTERN void delete_floatp(floatp *self){
 519   if (self) delete self;
 520 }
 521 SWIGINTERN void floatp_assign(floatp *self,float value){
 522   *self = value;
 523 }
 524 SWIGINTERN float floatp_value(floatp *self){
 525   return *self;
 526 }
 527 SWIGINTERN float *floatp_cast(floatp *self){
 528   return self;
 529 }
 530 SWIGINTERN floatp *floatp_frompointer(float *t){
 531   return (floatp *) t;
 532 }
 533
 534 typedef int intp;
 535
 536 SWIGINTERN intp *new_intp(){
 537   return new int();
 538 }
 539 SWIGINTERN void delete_intp(intp *self){
 540   if (self) delete self;
 541 }
 542 SWIGINTERN void intp_assign(intp *self,int value){
 543   *self = value;
 544 }
 545 SWIGINTERN int intp_value(intp *self){
 546   return *self;
 547 }
 548 SWIGINTERN int *intp_cast(intp *self){
 549   return self;
 550 }
 551 SWIGINTERN intp *intp_frompointer(int *t){
 552   return (intp *) t;
 553 }
 554
 555 typedef double doublep;
 556
 557 SWIGINTERN doublep *new_doublep(){
 558   return new double();
 559 }
 560 SWIGINTERN void delete_doublep(doublep *self){
 561   if (self) delete self;
 562 }
 563 SWIGINTERN void doublep_assign(doublep *self,double value){
 564   *self = value;
 565 }
 566 SWIGINTERN double doublep_value(doublep *self){
 567   return *self;
 568 }
 569 SWIGINTERN double *doublep_cast(doublep *self){
 570   return self;
 571 }
 572 SWIGINTERN doublep *doublep_frompointer(double *t){
 573   return (doublep *) t;
 574 }
 575
 576 typedef unsigned int uintp;
 577
 578 SWIGINTERN uintp *new_uintp(){
 579   return new unsigned int();
 580 }
 581 SWIGINTERN void delete_uintp(uintp *self){
 582   if (self) delete self;
 583 }
 584 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 585   *self = value;
 586 }
 587 SWIGINTERN unsigned int uintp_value(uintp *self){
 588   return *self;
 589 }
 590 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 591   return self;
 592 }
 593 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 594   return (uintp *) t;
 595 }
 596
 597 typedef unsigned short ushortp;
 598
 599 SWIGINTERN ushortp *new_ushortp(){
 600   return new unsigned short();
 601 }
 602 SWIGINTERN void delete_ushortp(ushortp *self){
 603   if (self) delete self;
 604 }
 605 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 606   *self = value;
 607 }
 608 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 609   return *self;
 610 }
 611 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 612   return self;
 613 }
 614 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 615   return (ushortp *) t;
 616 }
 617
 618 unsigned int int_to_uint(int x) {
 619    return (unsigned int) x;
 620 }
 621
 622
 623 using namespace Dali;
 624 using namespace Dali::Toolkit;
 625
 626 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 627 {
 628   bool result = false;
 629   try
 630   {
 631     // C++ code. DALi uses Handle <-> Body design pattern.
 632     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 633     // Handles in DALi can be converted into a boolean type
 634     // to check if the handle has a valid body attached to it.
 635     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 636     if( *self )
 637     {
 638       result = true;
 639     }
 640     else
 641     {
 642       result = false;
 643     }
 644   }
 645   catch (std::out_of_range& e)
 646   {
 647     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 648     return 0;
 649   }
 650   catch (std::exception& e)
 651   {
 652     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 653     return 0;
 654   }
 655   catch (DaliException e)
 656   {
 657     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 658     return 0;
 659   }
 660   catch (...)
 661   {
 662     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 663     return 0;
 664   }
 665   return result;
 666 }
 667
 668 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 669 {
 670   bool result = false;
 671   try
 672   {
 673     // C++ code. Check if two handles reference the same implemtion
 674     if( *self == rhs)
 675     {
 676       result = true;
 677     }
 678     else
 679     {
 680       result = false;
 681     }
 682   }
 683   catch (std::out_of_range& e)
 684   {
 685     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 686     return 0;
 687   }
 688   catch (std::exception& e)
 689   {
 690     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 691     return 0;
 692   }
 693   catch (DaliException e)
 694   {
 695     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 696     return 0;
 697   }
 698   catch (...)
 699   {
 700     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 701     return 0;
 702   }
 703   return result;
 704 }
 705
 706
 707 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 708      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 709    }
 710 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){
 711      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 712    }
 713 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 714         std::vector< Dali::TouchPoint >* pv = 0;
 715         if (capacity >= 0) {
 716           pv = new std::vector< Dali::TouchPoint >();
 717           pv->reserve(capacity);
 718        } else {
 719           throw std::out_of_range("capacity");
 720        }
 721        return pv;
 722       }
 723 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 724         if (index>=0 && index<(int)self->size())
 725           return (*self)[index];
 726         else
 727           throw std::out_of_range("index");
 728       }
 729 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 730         if (index>=0 && index<(int)self->size())
 731           return (*self)[index];
 732         else
 733           throw std::out_of_range("index");
 734       }
 735 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 736         if (index>=0 && index<(int)self->size())
 737           (*self)[index] = val;
 738         else
 739           throw std::out_of_range("index");
 740       }
 741 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 742         self->insert(self->end(), values.begin(), values.end());
 743       }
 744 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 745         if (index < 0)
 746           throw std::out_of_range("index");
 747         if (count < 0)
 748           throw std::out_of_range("count");
 749         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 750           throw std::invalid_argument("invalid range");
 751         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 752       }
 753 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 754         if (index>=0 && index<(int)self->size()+1)
 755           self->insert(self->begin()+index, x);
 756         else
 757           throw std::out_of_range("index");
 758       }
 759 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 760         if (index>=0 && index<(int)self->size()+1)
 761           self->insert(self->begin()+index, values.begin(), values.end());
 762         else
 763           throw std::out_of_range("index");
 764       }
 765 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 766         if (index>=0 && index<(int)self->size())
 767           self->erase(self->begin() + index);
 768         else
 769           throw std::out_of_range("index");
 770       }
 771 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 772         if (index < 0)
 773           throw std::out_of_range("index");
 774         if (count < 0)
 775           throw std::out_of_range("count");
 776         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 777           throw std::invalid_argument("invalid range");
 778         self->erase(self->begin()+index, self->begin()+index+count);
 779       }
 780 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 781         if (count < 0)
 782           throw std::out_of_range("count");
 783         return new std::vector< Dali::TouchPoint >(count, value);
 784       }
 785 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 786         std::reverse(self->begin(), self->end());
 787       }
 788 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 789         if (index < 0)
 790           throw std::out_of_range("index");
 791         if (count < 0)
 792           throw std::out_of_range("count");
 793         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 794           throw std::invalid_argument("invalid range");
 795         std::reverse(self->begin()+index, self->begin()+index+count);
 796       }
 797 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 798         if (index < 0)
 799           throw std::out_of_range("index");
 800         if (index+values.size() > self->size())
 801           throw std::out_of_range("index");
 802         std::copy(values.begin(), values.end(), self->begin()+index);
 803       }
 804 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 805          return self->Empty();
 806       }
 807 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 808         return self->GetConnectionCount();
 809       }
 810 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 811           self->Connect( func );
 812       }
 813 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 814           self->Disconnect( func );
 815       }
 816 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 817           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 818 /*@SWIG@*/ self->Emit( arg );
 819       }
 820 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 821          return self->Empty();
 822       }
 823 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 824         return self->GetConnectionCount();
 825       }
 826 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 827           self->Connect( func );
 828       }
 829 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 830           self->Disconnect( func );
 831       }
 832 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 833           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 834 /*@SWIG@*/ self->Emit( arg );
 835       }
 836 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 837          return self->Empty();
 838       }
 839 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){
 840         return self->GetConnectionCount();
 841       }
 842 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 *)){
 843           self->Connect( func );
 844       }
 845 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 *)){
 846           self->Disconnect( func );
 847       }
 848 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){
 849           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 850 /*@SWIG@*/ self->Emit( arg );
 851       }
 852 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 853          return self->Empty();
 854       }
 855 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 856         return self->GetConnectionCount();
 857       }
 858 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 859           self->Connect( func );
 860       }
 861 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 862           self->Disconnect( func );
 863       }
 864 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 865           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 866 /*@SWIG@*/ self->Emit( arg );
 867       }
 868 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 869          return self->Empty();
 870       }
 871 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 872         return self->GetConnectionCount();
 873       }
 874 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 875           self->Connect( func );
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 878           self->Disconnect( func );
 879       }
 880 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 881           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 882 /*@SWIG@*/ self->Emit( arg );
 883       }
 884 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){
 885          return self->Empty();
 886       }
 887 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){
 888         return self->GetConnectionCount();
 889       }
 890 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 &)){
 891         self->Connect( func );
 892       }
 893 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 &)){
 894         self->Disconnect( func );
 895       }
 896 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){
 897         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 898 /*@SWIG@*/ self->Emit( arg1, arg2 );
 899       }
 900 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){
 901          return self->Empty();
 902       }
 903 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){
 904         return self->GetConnectionCount();
 905       }
 906 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 &)){
 907         self->Connect( func );
 908       }
 909 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 &)){
 910         self->Disconnect( func );
 911       }
 912 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){
 913         return self->Emit( arg1, arg2 );
 914       }
 915 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){
 916          return self->Empty();
 917       }
 918 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){
 919         return self->GetConnectionCount();
 920       }
 921 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 &)){
 922         self->Connect( func );
 923       }
 924 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 &)){
 925         self->Disconnect( func );
 926       }
 927 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){
 928         return self->Emit( arg1, arg2 );
 929       }
 930 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){
 931          return self->Empty();
 932       }
 933 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){
 934         return self->GetConnectionCount();
 935       }
 936 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 &)){
 937         self->Connect( func );
 938       }
 939 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 &)){
 940         self->Disconnect( func );
 941       }
 942 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){
 943         return self->Emit( arg1, arg2 );
 944       }
 945 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 946          return self->Empty();
 947       }
 948 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 949         return self->GetConnectionCount();
 950       }
 951 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 952           self->Connect( func );
 953       }
 954 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 955           self->Disconnect( func );
 956       }
 957 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 958           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 959 /*@SWIG@*/ self->Emit( arg );
 960       }
 961 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 962          return self->Empty();
 963       }
 964 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){
 965         return self->GetConnectionCount();
 966       }
 967 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 &)){
 968           self->Connect( func );
 969       }
 970 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 &)){
 971           self->Disconnect( func );
 972       }
 973 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){
 974           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 975 /*@SWIG@*/ self->Emit( arg );
 976       }
 977 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 978          return self->Empty();
 979       }
 980 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){
 981         return self->GetConnectionCount();
 982       }
 983 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 &)){
 984           self->Connect( func );
 985       }
 986 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 &)){
 987           self->Disconnect( func );
 988       }
 989 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){
 990           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 991 /*@SWIG@*/ self->Emit( arg );
 992       }
 993 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 994          return self->Empty();
 995       }
 996 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){
 997         return self->GetConnectionCount();
 998       }
 999 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 &)){
1000           self->Connect( func );
1001       }
1002 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 &)){
1003           self->Disconnect( func );
1004       }
1005 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){
1006           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1007 /*@SWIG@*/ self->Emit( arg );
1008       }
1009 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){
1010          return self->Empty();
1011       }
1012 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){
1013         return self->GetConnectionCount();
1014       }
1015 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 &)){
1016         self->Connect( func );
1017       }
1018 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 &)){
1019         self->Disconnect( func );
1020       }
1021 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){
1022         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1023 /*@SWIG@*/ self->Emit( arg1, arg2 );
1024       }
1025 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){
1026          return self->Empty();
1027       }
1028 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){
1029         return self->GetConnectionCount();
1030       }
1031 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 &)){
1032         self->Connect( func );
1033       }
1034 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 &)){
1035         self->Disconnect( func );
1036       }
1037 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){
1038         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1039 /*@SWIG@*/ self->Emit( arg1, arg2 );
1040       }
1041 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){
1042          return self->Empty();
1043       }
1044 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){
1045         return self->GetConnectionCount();
1046       }
1047 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 &)){
1048         self->Connect( func );
1049       }
1050 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 &)){
1051         self->Disconnect( func );
1052       }
1053 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){
1054         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1055 /*@SWIG@*/ self->Emit( arg1, arg2 );
1056       }
1057 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1058          return self->Empty();
1059       }
1060 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1061         return self->GetConnectionCount();
1062       }
1063 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1064           self->Connect( func );
1065       }
1066 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1067           self->Disconnect( func );
1068       }
1069 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1070           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1071 /*@SWIG@*/ self->Emit( arg );
1072       }
1073 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){
1074          return self->Empty();
1075       }
1076 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){
1077         return self->GetConnectionCount();
1078       }
1079 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)){
1080           return self->Connect( func );
1081       }
1082 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)){
1083           self->Disconnect( func );
1084       }
1085 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){
1086           self->Emit( arg1, arg3 );
1087       }
1088 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){
1089          return self->Empty();
1090       }
1091 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){
1092         return self->GetConnectionCount();
1093       }
1094 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)){
1095           return self->Connect( func );
1096       }
1097 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)){
1098           self->Disconnect( func );
1099       }
1100 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){
1101           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1102 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1103       }
1104
1105 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1106          return self->Empty();
1107       }
1108 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1109         return self->GetConnectionCount();
1110       }
1111 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1112           self->Connect( func );
1113       }
1114 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1115           self->Disconnect( func );
1116       }
1117 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1118           return self->Emit();
1119       }
1120
1121 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1122         std::vector< unsigned int >* pv = 0;
1123         if (capacity >= 0) {
1124           pv = new std::vector< unsigned int >();
1125           pv->reserve(capacity);
1126        } else {
1127           throw std::out_of_range("capacity");
1128        }
1129        return pv;
1130       }
1131 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1132         if (index>=0 && index<(int)self->size())
1133           return (*self)[index];
1134         else
1135           throw std::out_of_range("index");
1136       }
1137 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1138         if (index>=0 && index<(int)self->size())
1139           return (*self)[index];
1140         else
1141           throw std::out_of_range("index");
1142       }
1143 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1144         if (index>=0 && index<(int)self->size())
1145           (*self)[index] = val;
1146         else
1147           throw std::out_of_range("index");
1148       }
1149 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1150         self->insert(self->end(), values.begin(), values.end());
1151       }
1152 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1153         if (index < 0)
1154           throw std::out_of_range("index");
1155         if (count < 0)
1156           throw std::out_of_range("count");
1157         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1158           throw std::invalid_argument("invalid range");
1159         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1160       }
1161 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1162         if (index>=0 && index<(int)self->size()+1)
1163           self->insert(self->begin()+index, x);
1164         else
1165           throw std::out_of_range("index");
1166       }
1167 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1168         if (index>=0 && index<(int)self->size()+1)
1169           self->insert(self->begin()+index, values.begin(), values.end());
1170         else
1171           throw std::out_of_range("index");
1172       }
1173 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1174         if (index>=0 && index<(int)self->size())
1175           self->erase(self->begin() + index);
1176         else
1177           throw std::out_of_range("index");
1178       }
1179 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1180         if (index < 0)
1181           throw std::out_of_range("index");
1182         if (count < 0)
1183           throw std::out_of_range("count");
1184         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1185           throw std::invalid_argument("invalid range");
1186         self->erase(self->begin()+index, self->begin()+index+count);
1187       }
1188 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1189         if (count < 0)
1190           throw std::out_of_range("count");
1191         return new std::vector< unsigned int >(count, value);
1192       }
1193 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1194         std::reverse(self->begin(), self->end());
1195       }
1196 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1197         if (index < 0)
1198           throw std::out_of_range("index");
1199         if (count < 0)
1200           throw std::out_of_range("count");
1201         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1202           throw std::invalid_argument("invalid range");
1203         std::reverse(self->begin()+index, self->begin()+index+count);
1204       }
1205 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1206         if (index < 0)
1207           throw std::out_of_range("index");
1208         if (index+values.size() > self->size())
1209           throw std::out_of_range("index");
1210         std::copy(values.begin(), values.end(), self->begin()+index);
1211       }
1212 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1213         return std::find(self->begin(), self->end(), value) != self->end();
1214       }
1215 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1216         int index = -1;
1217         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1218         if (it != self->end())
1219           index = (int)(it - self->begin());
1220         return index;
1221       }
1222 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1223         int index = -1;
1224         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1225         if (rit != self->rend())
1226           index = (int)(self->rend() - 1 - rit);
1227         return index;
1228       }
1229 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1230         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1231         if (it != self->end()) {
1232           self->erase(it);
1233           return true;
1234         }
1235         return false;
1236       }
1237 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){
1238         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1239         if (capacity >= 0) {
1240           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1241           pv->reserve(capacity);
1242        } else {
1243           throw std::out_of_range("capacity");
1244        }
1245        return pv;
1246       }
1247 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){
1248         if (index>=0 && index<(int)self->size())
1249           return (*self)[index];
1250         else
1251           throw std::out_of_range("index");
1252       }
1253 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){
1254         if (index>=0 && index<(int)self->size())
1255           return (*self)[index];
1256         else
1257           throw std::out_of_range("index");
1258       }
1259 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){
1260         if (index>=0 && index<(int)self->size())
1261           (*self)[index] = val;
1262         else
1263           throw std::out_of_range("index");
1264       }
1265 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){
1266         self->insert(self->end(), values.begin(), values.end());
1267       }
1268 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){
1269         if (index < 0)
1270           throw std::out_of_range("index");
1271         if (count < 0)
1272           throw std::out_of_range("count");
1273         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1274           throw std::invalid_argument("invalid range");
1275         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1276       }
1277 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){
1278         if (index>=0 && index<(int)self->size()+1)
1279           self->insert(self->begin()+index, x);
1280         else
1281           throw std::out_of_range("index");
1282       }
1283 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){
1284         if (index>=0 && index<(int)self->size()+1)
1285           self->insert(self->begin()+index, values.begin(), values.end());
1286         else
1287           throw std::out_of_range("index");
1288       }
1289 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){
1290         if (index>=0 && index<(int)self->size())
1291           self->erase(self->begin() + index);
1292         else
1293           throw std::out_of_range("index");
1294       }
1295 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){
1296         if (index < 0)
1297           throw std::out_of_range("index");
1298         if (count < 0)
1299           throw std::out_of_range("count");
1300         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1301           throw std::invalid_argument("invalid range");
1302         self->erase(self->begin()+index, self->begin()+index+count);
1303       }
1304 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){
1305         if (count < 0)
1306           throw std::out_of_range("count");
1307         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1308       }
1309 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){
1310         std::reverse(self->begin(), self->end());
1311       }
1312 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){
1313         if (index < 0)
1314           throw std::out_of_range("index");
1315         if (count < 0)
1316           throw std::out_of_range("count");
1317         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1318           throw std::invalid_argument("invalid range");
1319         std::reverse(self->begin()+index, self->begin()+index+count);
1320       }
1321 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){
1322         if (index < 0)
1323           throw std::out_of_range("index");
1324         if (index+values.size() > self->size())
1325           throw std::out_of_range("index");
1326         std::copy(values.begin(), values.end(), self->begin()+index);
1327       }
1328 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1329         std::vector< Dali::Actor >* pv = 0;
1330         if (capacity >= 0) {
1331           pv = new std::vector< Dali::Actor >();
1332           pv->reserve(capacity);
1333        } else {
1334           throw std::out_of_range("capacity");
1335        }
1336        return pv;
1337       }
1338 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1339         if (index>=0 && index<(int)self->size())
1340           return (*self)[index];
1341         else
1342           throw std::out_of_range("index");
1343       }
1344 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1345         if (index>=0 && index<(int)self->size())
1346           return (*self)[index];
1347         else
1348           throw std::out_of_range("index");
1349       }
1350 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1351         if (index>=0 && index<(int)self->size())
1352           (*self)[index] = val;
1353         else
1354           throw std::out_of_range("index");
1355       }
1356 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1357         self->insert(self->end(), values.begin(), values.end());
1358       }
1359 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1360         if (index < 0)
1361           throw std::out_of_range("index");
1362         if (count < 0)
1363           throw std::out_of_range("count");
1364         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1365           throw std::invalid_argument("invalid range");
1366         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1367       }
1368 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1369         if (index>=0 && index<(int)self->size()+1)
1370           self->insert(self->begin()+index, x);
1371         else
1372           throw std::out_of_range("index");
1373       }
1374 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1375         if (index>=0 && index<(int)self->size()+1)
1376           self->insert(self->begin()+index, values.begin(), values.end());
1377         else
1378           throw std::out_of_range("index");
1379       }
1380 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1381         if (index>=0 && index<(int)self->size())
1382           self->erase(self->begin() + index);
1383         else
1384           throw std::out_of_range("index");
1385       }
1386 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1387         if (index < 0)
1388           throw std::out_of_range("index");
1389         if (count < 0)
1390           throw std::out_of_range("count");
1391         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1392           throw std::invalid_argument("invalid range");
1393         self->erase(self->begin()+index, self->begin()+index+count);
1394       }
1395 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1396         if (count < 0)
1397           throw std::out_of_range("count");
1398         return new std::vector< Dali::Actor >(count, value);
1399       }
1400 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1401         std::reverse(self->begin(), self->end());
1402       }
1403 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1404         if (index < 0)
1405           throw std::out_of_range("index");
1406         if (count < 0)
1407           throw std::out_of_range("count");
1408         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1409           throw std::invalid_argument("invalid range");
1410         std::reverse(self->begin()+index, self->begin()+index+count);
1411       }
1412 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1413         if (index < 0)
1414           throw std::out_of_range("index");
1415         if (index+values.size() > self->size())
1416           throw std::out_of_range("index");
1417         std::copy(values.begin(), values.end(), self->begin()+index);
1418       }
1419 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1420          return self->Empty();
1421       }
1422 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1423         return self->GetConnectionCount();
1424       }
1425 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 &)){
1426           self->Connect( func );
1427       }
1428 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 &)){
1429           self->Disconnect( func );
1430       }
1431 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){
1432           return self->Emit( arg );
1433       }
1434 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){
1435          return self->Empty();
1436       }
1437 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){
1438         return self->GetConnectionCount();
1439       }
1440 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)){
1441         self->Connect( func );
1442       }
1443 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)){
1444         self->Disconnect( func );
1445       }
1446 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){
1447         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1448 /*@SWIG@*/ self->Emit( arg1, arg2 );
1449       }
1450 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1451          return self->Empty();
1452       }
1453 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){
1454         return self->GetConnectionCount();
1455       }
1456 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)){
1457         self->Connect( func );
1458       }
1459 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)){
1460         self->Disconnect( func );
1461       }
1462 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){
1463         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1464 /*@SWIG@*/ self->Emit( arg1, arg2 );
1465       }
1466 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1467          return self->Empty();
1468       }
1469 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1470         return self->GetConnectionCount();
1471       }
1472 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)){
1473         self->Connect( func );
1474       }
1475 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)){
1476         self->Disconnect( func );
1477       }
1478 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){
1479         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1480 /*@SWIG@*/ self->Emit( arg1, arg2 );
1481       }
1482 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){
1483          return self->Empty();
1484       }
1485 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){
1486         return self->GetConnectionCount();
1487       }
1488 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)){
1489         self->Connect( func );
1490       }
1491 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)){
1492         self->Disconnect( func );
1493       }
1494 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){
1495         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1496 /*@SWIG@*/ self->Emit( arg1, arg2 );
1497       }
1498 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1499          return self->Empty();
1500       }
1501 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1502         return self->GetConnectionCount();
1503       }
1504 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)){
1505           self->Connect( func );
1506       }
1507 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)){
1508           self->Disconnect( func );
1509       }
1510 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1511           return self->Emit( arg );
1512       }
1513 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1514          return self->Empty();
1515       }
1516 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1517         return self->GetConnectionCount();
1518       }
1519 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)){
1520           self->Connect( func );
1521       }
1522 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)){
1523           self->Disconnect( func );
1524       }
1525 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1526           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1527 /*@SWIG@*/ self->Emit( arg );
1528       }
1529 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){
1530          return self->Empty();
1531       }
1532 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){
1533         return self->GetConnectionCount();
1534       }
1535 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)){
1536           return self->Connect( func );
1537       }
1538 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)){
1539           self->Disconnect( func );
1540       }
1541 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){
1542           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1543 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1544       }
1545 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1546          return self->Empty();
1547       }
1548 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1549         return self->GetConnectionCount();
1550       }
1551 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)){
1552           self->Connect( func );
1553       }
1554 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)){
1555           self->Disconnect( func );
1556       }
1557 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1558           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1559 /*@SWIG@*/ self->Emit( arg );
1560       }
1561 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){
1562          return self->Empty();
1563       }
1564 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){
1565         return self->GetConnectionCount();
1566       }
1567 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)){
1568           return self->Connect( func );
1569       }
1570 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)){
1571           self->Disconnect( func );
1572       }
1573 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){
1574           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1575 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1576       }
1577 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){
1578          return self->Empty();
1579       }
1580 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){
1581         return self->GetConnectionCount();
1582       }
1583 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 &)){
1584           self->Connect( func );
1585       }
1586 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 &)){
1587           self->Disconnect( func );
1588       }
1589 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){
1590           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1591 /*@SWIG@*/ self->Emit( arg );
1592       }
1593 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1594          return self->Empty();
1595       }
1596 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){
1597         return self->GetConnectionCount();
1598       }
1599 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 &)){
1600           self->Connect( func );
1601       }
1602 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 &)){
1603           self->Disconnect( func );
1604       }
1605 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){
1606           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1607 /*@SWIG@*/ self->Emit( arg );
1608       }
1609
1610
1611 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){
1612          return self->Empty();
1613       }
1614 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){
1615         return self->GetConnectionCount();
1616       }
1617 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 &)){
1618         self->Connect( func );
1619       }
1620 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 &)){
1621         self->Disconnect( func );
1622       }
1623 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){
1624         return self->Emit( arg1, arg2 );
1625       }
1626 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1627          return self->Empty();
1628       }
1629 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1630         return self->GetConnectionCount();
1631       }
1632 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)){
1633           self->Connect( func );
1634       }
1635 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)){
1636           self->Disconnect( func );
1637       }
1638 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1639           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1640 /*@SWIG@*/ self->Emit( arg );
1641       }
1642 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1643          return self->Empty();
1644       }
1645 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1646         return self->GetConnectionCount();
1647       }
1648 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 &)){
1649           self->Connect( func );
1650       }
1651 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 &)){
1652           self->Disconnect( func );
1653       }
1654 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){
1655           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1656 /*@SWIG@*/ self->Emit( arg );
1657       }
1658 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1659          return self->Empty();
1660       }
1661 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){
1662         return self->GetConnectionCount();
1663       }
1664 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)){
1665         self->Connect( func );
1666       }
1667 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)){
1668         self->Disconnect( func );
1669       }
1670 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){
1671         return self->Emit( arg1, arg2 );
1672       }
1673 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1674          return self->Empty();
1675       }
1676 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){
1677         return self->GetConnectionCount();
1678       }
1679 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)){
1680         self->Connect( func );
1681       }
1682 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)){
1683         self->Disconnect( func );
1684       }
1685 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){
1686         return self->Emit( arg1, arg2 );
1687       }
1688
1689 /* ---------------------------------------------------
1690  * C++ director class methods
1691  * --------------------------------------------------- */
1692
1693 #include "dali_wrap.h"
1694
1695 /*
1696  *  Widget director
1697  */
1698 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1699   swig_init_callbacks();
1700 }
1701
1702 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1703 }
1704
1705 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1706   char * jcontentInfo = 0 ;
1707   void * jwindow  ;
1708
1709   if (!swig_callbackOnCreate) {
1710     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1711     return;
1712   } else {
1713     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1714     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1715     swig_callbackOnCreate(jcontentInfo, jwindow);
1716   }
1717 }
1718
1719 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1720   char * jcontentInfo = 0 ;
1721   int jtype  ;
1722
1723   if (!swig_callbackOnTerminate) {
1724     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1725     return;
1726   } else {
1727     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1728     jtype = (int)type;
1729     swig_callbackOnTerminate(jcontentInfo, jtype);
1730   }
1731 }
1732
1733 void SwigDirector_WidgetImpl::OnPause() {
1734   if (!swig_callbackOnPause) {
1735     Dali::Internal::Adaptor::Widget::OnPause();
1736     return;
1737   } else {
1738     swig_callbackOnPause();
1739   }
1740 }
1741
1742 void SwigDirector_WidgetImpl::OnResume() {
1743   if (!swig_callbackOnResume) {
1744     Dali::Internal::Adaptor::Widget::OnResume();
1745     return;
1746   } else {
1747     swig_callbackOnResume();
1748   }
1749 }
1750
1751 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1752   void * jwindow  ;
1753
1754   if (!swig_callbackOnResize) {
1755     Dali::Internal::Adaptor::Widget::OnResize(window);
1756     return;
1757   } else {
1758     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1759     swig_callbackOnResize(jwindow);
1760   }
1761 }
1762
1763 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1764   char * jcontentInfo = 0 ;
1765   int jforce  ;
1766
1767   if (!swig_callbackOnUpdate) {
1768     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1769     return;
1770   } else {
1771     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1772     jforce = force;
1773     swig_callbackOnUpdate(jcontentInfo, jforce);
1774   }
1775 }
1776
1777 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1778   void * jslotObserver = 0 ;
1779   void * jcallback = 0 ;
1780
1781   if (!swig_callbackSignalConnected) {
1782     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1783     return;
1784   } else {
1785     jslotObserver = (void *) slotObserver;
1786     jcallback = (void *) callback;
1787     swig_callbackSignalConnected(jslotObserver, jcallback);
1788   }
1789 }
1790
1791 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1792   void * jslotObserver = 0 ;
1793   void * jcallback = 0 ;
1794
1795   if (!swig_callbackSignalDisconnected) {
1796     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1797     return;
1798   } else {
1799     jslotObserver = (void *) slotObserver;
1800     jcallback = (void *) callback;
1801     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1802   }
1803 }
1804
1805 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) {
1806
1807   swig_callbackOnCreate = callbackOnCreate;
1808   swig_callbackOnTerminate = callbackOnTerminate;
1809   swig_callbackOnPause = callbackOnPause;
1810   swig_callbackOnResume = callbackOnResume;
1811   swig_callbackOnResize = callbackOnResize;
1812   swig_callbackOnUpdate = callbackOnUpdate;
1813   swig_callbackSignalConnected = callbackSignalConnected;
1814   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1815 }
1816
1817 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1818   swig_callbackOnCreate = 0;
1819   swig_callbackOnTerminate = 0;
1820   swig_callbackOnPause = 0;
1821   swig_callbackOnResume = 0;
1822   swig_callbackOnResize = 0;
1823   swig_callbackOnUpdate = 0;
1824   swig_callbackSignalConnected = 0;
1825   swig_callbackSignalDisconnected = 0;
1826 }
1827
1828
1829 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1830   swig_init_callbacks();
1831 }
1832
1833 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1834
1835 }
1836
1837
1838 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1839   int jdepth  ;
1840
1841   if (!swig_callbackOnStageConnection) {
1842     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1843     return;
1844   } else {
1845     jdepth = depth;
1846     swig_callbackOnStageConnection(jdepth);
1847   }
1848 }
1849
1850 void SwigDirector_ViewImpl::OnStageDisconnection() {
1851   if (!swig_callbackOnStageDisconnection) {
1852     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1853     return;
1854   } else {
1855     swig_callbackOnStageDisconnection();
1856   }
1857 }
1858
1859 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1860   void * jchild = 0 ;
1861
1862   if (!swig_callbackOnChildAdd) {
1863     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1864     return;
1865   } else {
1866     jchild = (Dali::Actor *) &child;
1867     swig_callbackOnChildAdd(jchild);
1868   }
1869 }
1870
1871 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1872   void * jchild = 0 ;
1873
1874   if (!swig_callbackOnChildRemove) {
1875     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1876     return;
1877   } else {
1878     jchild = (Dali::Actor *) &child;
1879     swig_callbackOnChildRemove(jchild);
1880   }
1881 }
1882
1883 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1884   int jindex  ;
1885   void * jpropertyValue  ;
1886
1887   if (!swig_callbackOnPropertySet) {
1888     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1889     return;
1890   } else {
1891     jindex = index;
1892     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1893     swig_callbackOnPropertySet(jindex, jpropertyValue);
1894   }
1895 }
1896
1897 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1898   void * jtargetSize = 0 ;
1899
1900   if (!swig_callbackOnSizeSet) {
1901     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1902     return;
1903   } else {
1904     jtargetSize = (Dali::Vector3 *) &targetSize;
1905     swig_callbackOnSizeSet(jtargetSize);
1906   }
1907 }
1908
1909 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1910   void * janimation = 0 ;
1911   void * jtargetSize = 0 ;
1912
1913   if (!swig_callbackOnSizeAnimation) {
1914     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1915     return;
1916   } else {
1917     janimation = (Dali::Animation *) &animation;
1918     jtargetSize = (Dali::Vector3 *) &targetSize;
1919     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1920   }
1921 }
1922
1923 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1924   bool c_result = SwigValueInit< bool >() ;
1925   unsigned int jresult = 0 ;
1926   void * jarg0 = 0 ;
1927
1928   if (!swig_callbackOnTouchEvent) {
1929     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1930   } else {
1931     jarg0 = (Dali::TouchEvent *) &event;
1932     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1933     c_result = jresult ? true : false;
1934   }
1935   return c_result;
1936 }
1937
1938 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1939   bool c_result = SwigValueInit< bool >() ;
1940   unsigned int jresult = 0 ;
1941   void * jarg0 = 0 ;
1942
1943   if (!swig_callbackOnHoverEvent) {
1944     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1945   } else {
1946     jarg0 = (Dali::HoverEvent *) &event;
1947     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1948     c_result = jresult ? true : false;
1949   }
1950   return c_result;
1951 }
1952
1953 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1954   bool c_result = SwigValueInit< bool >() ;
1955   unsigned int jresult = 0 ;
1956   void * jarg0 = 0 ;
1957
1958   if (!swig_callbackOnKeyEvent) {
1959     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1960   } else {
1961     jarg0 = (Dali::KeyEvent *) &event;
1962     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1963     c_result = jresult ? true : false;
1964   }
1965   return c_result;
1966 }
1967
1968 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1969   bool c_result = SwigValueInit< bool >() ;
1970   unsigned int jresult = 0 ;
1971   void * jarg0 = 0 ;
1972
1973   if (!swig_callbackOnWheelEvent) {
1974     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1975   } else {
1976     jarg0 = (Dali::WheelEvent *) &event;
1977     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1978     c_result = jresult ? true : false;
1979   }
1980   return c_result;
1981 }
1982
1983 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1984   void * jsize = 0 ;
1985   void * jcontainer = 0 ;
1986
1987   if (!swig_callbackOnRelayout) {
1988     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1989     return;
1990   } else {
1991     jsize = (Dali::Vector2 *) &size;
1992     jcontainer = (Dali::RelayoutContainer *) &container;
1993     swig_callbackOnRelayout(jsize, jcontainer);
1994   }
1995 }
1996
1997 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1998   int jpolicy  ;
1999   int jdimension  ;
2000
2001   if (!swig_callbackOnSetResizePolicy) {
2002     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2003     return;
2004   } else {
2005     jpolicy = (int)policy;
2006     jdimension = (int)dimension;
2007     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2008   }
2009 }
2010
2011 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2012   Dali::Vector3 c_result ;
2013   void * jresult = 0 ;
2014
2015   if (!swig_callbackGetNaturalSize) {
2016     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2017   } else {
2018     jresult = (void *) swig_callbackGetNaturalSize();
2019     if (!jresult) {
2020       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2021       return c_result;
2022     }
2023     c_result = *(Dali::Vector3 *)jresult;
2024   }
2025   return c_result;
2026 }
2027
2028 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2029   float c_result = SwigValueInit< float >() ;
2030   float jresult = 0 ;
2031   void * jchild = 0 ;
2032   int jdimension  ;
2033
2034   if (!swig_callbackCalculateChildSize) {
2035     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2036   } else {
2037     jchild = (Dali::Actor *) &child;
2038     jdimension = (int)dimension;
2039     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2040     c_result = (float)jresult;
2041   }
2042   return c_result;
2043 }
2044
2045 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2046   float c_result = SwigValueInit< float >() ;
2047   float jresult = 0 ;
2048   float jwidth  ;
2049
2050   if (!swig_callbackGetHeightForWidth) {
2051     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2052   } else {
2053     jwidth = width;
2054     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2055     c_result = (float)jresult;
2056   }
2057   return c_result;
2058 }
2059
2060 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2061   float c_result = SwigValueInit< float >() ;
2062   float jresult = 0 ;
2063   float jheight  ;
2064
2065   if (!swig_callbackGetWidthForHeight) {
2066     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2067   } else {
2068     jheight = height;
2069     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2070     c_result = (float)jresult;
2071   }
2072   return c_result;
2073 }
2074
2075 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2076   bool c_result = SwigValueInit< bool >() ;
2077   unsigned int jresult = 0 ;
2078   int jdimension  ;
2079
2080   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2081     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2082   } else {
2083     jdimension = (int)dimension;
2084     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2085     c_result = jresult ? true : false;
2086   }
2087   return c_result;
2088 }
2089
2090 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2091   int jdimension  ;
2092
2093   if (!swig_callbackOnCalculateRelayoutSize) {
2094     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2095     return;
2096   } else {
2097     jdimension = (int)dimension;
2098     swig_callbackOnCalculateRelayoutSize(jdimension);
2099   }
2100 }
2101
2102 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2103   float jsize  ;
2104   int jdimension  ;
2105
2106   if (!swig_callbackOnLayoutNegotiated) {
2107     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2108     return;
2109   } else {
2110     jsize = size;
2111     jdimension = (int)dimension;
2112     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2113   }
2114 }
2115
2116 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2117   return Dali::CustomActorImpl::GetExtension();
2118 }
2119
2120 void SwigDirector_ViewImpl::OnInitialize() {
2121   if (!swig_callbackOnInitialize) {
2122     Dali::Toolkit::Internal::Control::OnInitialize();
2123     return;
2124   } else {
2125     swig_callbackOnInitialize();
2126   }
2127 }
2128
2129 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2130   void * jchild = 0 ;
2131
2132   if (!swig_callbackOnControlChildAdd) {
2133     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2134     return;
2135   } else {
2136     jchild = (Dali::Actor *) &child;
2137     swig_callbackOnControlChildAdd(jchild);
2138   }
2139 }
2140
2141 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2142   void * jchild = 0 ;
2143
2144   if (!swig_callbackOnControlChildRemove) {
2145     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2146     return;
2147   } else {
2148     jchild = (Dali::Actor *) &child;
2149     swig_callbackOnControlChildRemove(jchild);
2150   }
2151 }
2152
2153 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2154   void * jstyleManager  ;
2155   int jchange  ;
2156
2157   if (!swig_callbackOnStyleChange) {
2158     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2159     return;
2160   } else {
2161     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2162     jchange = (int)change;
2163     swig_callbackOnStyleChange(jstyleManager, jchange);
2164   }
2165 }
2166
2167 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2168   bool c_result = SwigValueInit< bool >() ;
2169   unsigned int jresult = 0 ;
2170
2171   if (!swig_callbackOnAccessibilityActivated) {
2172     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2173   } else {
2174     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2175     c_result = jresult ? true : false;
2176   }
2177   return c_result;
2178 }
2179
2180 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2181   bool c_result = SwigValueInit< bool >() ;
2182   unsigned int jresult = 0 ;
2183   void * jgesture  ;
2184
2185   if (!swig_callbackOnAccessibilityPan) {
2186     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2187   } else {
2188     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2189     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2190     c_result = jresult ? true : false;
2191   }
2192   return c_result;
2193 }
2194
2195 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2196   bool c_result = SwigValueInit< bool >() ;
2197   unsigned int jresult = 0 ;
2198   void * jtouchEvent = 0 ;
2199
2200   if (!swig_callbackOnAccessibilityTouch) {
2201     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2202   } else {
2203     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2204     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2205     c_result = jresult ? true : false;
2206   }
2207   return c_result;
2208 }
2209
2210 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2211   bool c_result = SwigValueInit< bool >() ;
2212   unsigned int jresult = 0 ;
2213   unsigned int jisIncrease  ;
2214
2215   if (!swig_callbackOnAccessibilityValueChange) {
2216     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2217   } else {
2218     jisIncrease = isIncrease;
2219     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2220     c_result = jresult ? true : false;
2221   }
2222   return c_result;
2223 }
2224
2225 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2226   bool c_result = SwigValueInit< bool >() ;
2227   unsigned int jresult = 0 ;
2228
2229   if (!swig_callbackOnAccessibilityZoom) {
2230     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2231   } else {
2232     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2233     c_result = jresult ? true : false;
2234   }
2235   return c_result;
2236 }
2237
2238 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2239   if (!swig_callbackOnKeyInputFocusGained) {
2240     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2241     return;
2242   } else {
2243     swig_callbackOnKeyInputFocusGained();
2244   }
2245 }
2246
2247 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2248   if (!swig_callbackOnKeyInputFocusLost) {
2249     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2250     return;
2251   } else {
2252     swig_callbackOnKeyInputFocusLost();
2253   }
2254 }
2255
2256 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2257   Dali::Actor c_result ;
2258   void * jresult = 0 ;
2259   void * jcurrentFocusedActor  ;
2260   int jdirection  ;
2261   unsigned int jloopEnabled  ;
2262
2263   if (!swig_callbackGetNextKeyboardFocusableActor) {
2264     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2265   } else {
2266     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2267     jdirection = (int)direction;
2268     jloopEnabled = loopEnabled;
2269     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2270     if (!jresult) {
2271       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2272       return c_result;
2273     }
2274     c_result = *(Dali::Actor *)jresult;
2275   }
2276   return c_result;
2277 }
2278
2279 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2280   void * jcommitedFocusableActor  ;
2281
2282   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2283     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2284     return;
2285   } else {
2286     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2287     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2288   }
2289 }
2290
2291 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2292   bool c_result = SwigValueInit< bool >() ;
2293   unsigned int jresult = 0 ;
2294
2295   if (!swig_callbackOnKeyboardEnter) {
2296     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2297   } else {
2298     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2299     c_result = jresult ? true : false;
2300   }
2301   return c_result;
2302 }
2303
2304 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2305   void * jpinch = 0 ;
2306
2307   if (!swig_callbackOnPinch) {
2308     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2309     return;
2310   } else {
2311     jpinch = (Dali::PinchGesture *) &pinch;
2312     swig_callbackOnPinch(jpinch);
2313   }
2314 }
2315
2316 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2317   void * jpan = 0 ;
2318
2319   if (!swig_callbackOnPan) {
2320     Dali::Toolkit::Internal::Control::OnPan(pan);
2321     return;
2322   } else {
2323     jpan = (Dali::PanGesture *) &pan;
2324     swig_callbackOnPan(jpan);
2325   }
2326 }
2327
2328 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2329   void * jtap = 0 ;
2330
2331   if (!swig_callbackOnTap) {
2332     Dali::Toolkit::Internal::Control::OnTap(tap);
2333     return;
2334   } else {
2335     jtap = (Dali::TapGesture *) &tap;
2336     swig_callbackOnTap(jtap);
2337   }
2338 }
2339
2340 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2341   void * jlongPress = 0 ;
2342
2343   if (!swig_callbackOnLongPress) {
2344     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2345     return;
2346   } else {
2347     jlongPress = (Dali::LongPressGesture *) &longPress;
2348     swig_callbackOnLongPress(jlongPress);
2349   }
2350 }
2351
2352 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2353   void * jslotObserver = 0 ;
2354   void * jcallback = 0 ;
2355
2356   if (!swig_callbackSignalConnected) {
2357     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2358     return;
2359   } else {
2360     jslotObserver = (void *) slotObserver;
2361     jcallback = (void *) callback;
2362     swig_callbackSignalConnected(jslotObserver, jcallback);
2363   }
2364 }
2365
2366 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2367   void * jslotObserver = 0 ;
2368   void * jcallback = 0 ;
2369
2370   if (!swig_callbackSignalDisconnected) {
2371     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2372     return;
2373   } else {
2374     jslotObserver = (void *) slotObserver;
2375     jcallback = (void *) callback;
2376     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2377   }
2378 }
2379
2380 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2381   return Dali::Toolkit::Internal::Control::GetControlExtension();
2382 }
2383
2384 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) {
2385   swig_callbackOnStageConnection = callbackOnStageConnection;
2386   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2387   swig_callbackOnChildAdd = callbackOnChildAdd;
2388   swig_callbackOnChildRemove = callbackOnChildRemove;
2389   swig_callbackOnPropertySet = callbackOnPropertySet;
2390   swig_callbackOnSizeSet = callbackOnSizeSet;
2391   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2392   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2393   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2394   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2395   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2396   swig_callbackOnRelayout = callbackOnRelayout;
2397   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2398   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2399   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2400   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2401   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2402   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2403   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2404   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2405   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2406   swig_callbackOnInitialize = callbackOnInitialize;
2407   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2408   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2409   swig_callbackOnStyleChange = callbackOnStyleChange;
2410   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2411   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2412   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2413   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2414   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2415   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2416   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2417   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2418   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2419   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2420   swig_callbackOnPinch = callbackOnPinch;
2421   swig_callbackOnPan = callbackOnPan;
2422   swig_callbackOnTap = callbackOnTap;
2423   swig_callbackOnLongPress = callbackOnLongPress;
2424   swig_callbackSignalConnected = callbackSignalConnected;
2425   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2426 }
2427
2428 void SwigDirector_ViewImpl::swig_init_callbacks() {
2429   swig_callbackOnStageConnection = 0;
2430   swig_callbackOnStageDisconnection = 0;
2431   swig_callbackOnChildAdd = 0;
2432   swig_callbackOnChildRemove = 0;
2433   swig_callbackOnPropertySet = 0;
2434   swig_callbackOnSizeSet = 0;
2435   swig_callbackOnSizeAnimation = 0;
2436   swig_callbackOnTouchEvent = 0;
2437   swig_callbackOnHoverEvent = 0;
2438   swig_callbackOnKeyEvent = 0;
2439   swig_callbackOnWheelEvent = 0;
2440   swig_callbackOnRelayout = 0;
2441   swig_callbackOnSetResizePolicy = 0;
2442   swig_callbackGetNaturalSize = 0;
2443   swig_callbackCalculateChildSize = 0;
2444   swig_callbackGetHeightForWidth = 0;
2445   swig_callbackGetWidthForHeight = 0;
2446   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2447   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2448   swig_callbackOnCalculateRelayoutSize = 0;
2449   swig_callbackOnLayoutNegotiated = 0;
2450   swig_callbackOnInitialize = 0;
2451   swig_callbackOnControlChildAdd = 0;
2452   swig_callbackOnControlChildRemove = 0;
2453   swig_callbackOnStyleChange = 0;
2454   swig_callbackOnAccessibilityActivated = 0;
2455   swig_callbackOnAccessibilityPan = 0;
2456   swig_callbackOnAccessibilityTouch = 0;
2457   swig_callbackOnAccessibilityValueChange = 0;
2458   swig_callbackOnAccessibilityZoom = 0;
2459   swig_callbackOnKeyInputFocusGained = 0;
2460   swig_callbackOnKeyInputFocusLost = 0;
2461   swig_callbackGetNextKeyboardFocusableActor = 0;
2462   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2463   swig_callbackOnKeyboardEnter = 0;
2464   swig_callbackOnPinch = 0;
2465   swig_callbackOnPan = 0;
2466   swig_callbackOnTap = 0;
2467   swig_callbackOnLongPress = 0;
2468   swig_callbackSignalConnected = 0;
2469   swig_callbackSignalDisconnected = 0;
2470 }
2471
2472 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2473   swig_init_callbacks();
2474 }
2475
2476 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2477
2478 }
2479
2480
2481 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2482   unsigned int c_result = SwigValueInit< unsigned int >() ;
2483   unsigned int jresult = 0 ;
2484
2485   if (!swig_callbackGetNumberOfItems) {
2486     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2487   } else {
2488     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2489     c_result = (unsigned int)jresult;
2490   }
2491   return c_result;
2492 }
2493
2494 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2495   Dali::Actor c_result ;
2496   void * jresult = 0 ;
2497   unsigned int jitemId  ;
2498
2499   if (!swig_callbackNewItem) {
2500     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2501   } else {
2502     jitemId = itemId;
2503     jresult = (void *) swig_callbackNewItem(jitemId);
2504     if (!jresult) {
2505       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2506       return c_result;
2507     }
2508     c_result = *(Dali::Actor *)jresult;
2509   }
2510   return c_result;
2511 }
2512
2513 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2514   unsigned int jitemId  ;
2515   void * jactor  ;
2516
2517   if (!swig_callbackItemReleased) {
2518     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2519     return;
2520   } else {
2521     jitemId = itemId;
2522     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2523     swig_callbackItemReleased(jitemId, jactor);
2524   }
2525 }
2526
2527 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2528   return Dali::Toolkit::ItemFactory::GetExtension();
2529 }
2530
2531 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2532   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2533   swig_callbackNewItem = callbackNewItem;
2534   swig_callbackItemReleased = callbackItemReleased;
2535 }
2536
2537 void SwigDirector_ItemFactory::swig_init_callbacks() {
2538   swig_callbackGetNumberOfItems = 0;
2539   swig_callbackNewItem = 0;
2540   swig_callbackItemReleased = 0;
2541 }
2542
2543 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2544   swig_init_callbacks();
2545 }
2546
2547 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2548
2549 }
2550
2551
2552 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2553   Dali::Actor c_result ;
2554   void * jresult = 0 ;
2555   void * jcurrent  ;
2556   void * jproposed  ;
2557   int jdirection  ;
2558
2559   if (!swig_callbackGetNextFocusableActor) {
2560     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2561   } else {
2562     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2563     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2564     jdirection = (int)direction;
2565     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2566     if (!jresult) {
2567       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2568       return c_result;
2569     }
2570     c_result = *(Dali::Actor *)jresult;
2571   }
2572   return c_result;
2573 }
2574
2575 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2576   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2577 }
2578
2579 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2580   swig_callbackGetNextFocusableActor = 0;
2581 }
2582
2583
2584 #ifdef __cplusplus
2585 extern "C" {
2586 #endif
2587
2588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2589   void * jresult ;
2590   floatp *result = 0 ;
2591
2592   {
2593     try {
2594       result = (floatp *)new_floatp();
2595     } catch (std::out_of_range& e) {
2596       {
2597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2598       };
2599     } catch (std::exception& e) {
2600       {
2601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2602       };
2603     } catch (DaliException e) {
2604       {
2605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2606       };
2607     } catch (...) {
2608       {
2609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2610       };
2611     }
2612   }
2613   jresult = (void *)result;
2614   return jresult;
2615 }
2616
2617
2618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2619   floatp *arg1 = (floatp *) 0 ;
2620
2621   arg1 = (floatp *)jarg1;
2622   {
2623     try {
2624       delete_floatp(arg1);
2625     } catch (std::out_of_range& e) {
2626       {
2627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2628       };
2629     } catch (std::exception& e) {
2630       {
2631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2632       };
2633     } catch (Dali::DaliException e) {
2634       {
2635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2636       };
2637     } catch (...) {
2638       {
2639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2640       };
2641     }
2642   }
2643
2644 }
2645
2646
2647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2648   floatp *arg1 = (floatp *) 0 ;
2649   float arg2 ;
2650
2651   arg1 = (floatp *)jarg1;
2652   arg2 = (float)jarg2;
2653   {
2654     try {
2655       floatp_assign(arg1,arg2);
2656     } catch (std::out_of_range& e) {
2657       {
2658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2659       };
2660     } catch (std::exception& e) {
2661       {
2662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2663       };
2664     } catch (Dali::DaliException e) {
2665       {
2666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2667       };
2668     } catch (...) {
2669       {
2670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2671       };
2672     }
2673   }
2674
2675 }
2676
2677
2678 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2679   float jresult ;
2680   floatp *arg1 = (floatp *) 0 ;
2681   float result;
2682
2683   arg1 = (floatp *)jarg1;
2684   {
2685     try {
2686       result = (float)floatp_value(arg1);
2687     } catch (std::out_of_range& e) {
2688       {
2689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2690       };
2691     } catch (std::exception& e) {
2692       {
2693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2694       };
2695     } catch (DaliException e) {
2696       {
2697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2698       };
2699     } catch (...) {
2700       {
2701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2702       };
2703     }
2704   }
2705   jresult = result;
2706   return jresult;
2707 }
2708
2709
2710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2711   void * jresult ;
2712   floatp *arg1 = (floatp *) 0 ;
2713   float *result = 0 ;
2714
2715   arg1 = (floatp *)jarg1;
2716   {
2717     try {
2718       result = (float *)floatp_cast(arg1);
2719     } catch (std::out_of_range& e) {
2720       {
2721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2722       };
2723     } catch (std::exception& e) {
2724       {
2725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2726       };
2727     } catch (Dali::DaliException e) {
2728       {
2729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2730       };
2731     } catch (...) {
2732       {
2733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2734       };
2735     }
2736   }
2737
2738   jresult = (void *)result;
2739   return jresult;
2740 }
2741
2742
2743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2744   void * jresult ;
2745   float *arg1 = (float *) 0 ;
2746   floatp *result = 0 ;
2747
2748   arg1 = (float *)jarg1;
2749   {
2750     try {
2751       result = (floatp *)floatp_frompointer(arg1);
2752     } catch (std::out_of_range& e) {
2753       {
2754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2755       };
2756     } catch (std::exception& e) {
2757       {
2758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2759       };
2760     } catch (Dali::DaliException e) {
2761       {
2762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2763       };
2764     } catch (...) {
2765       {
2766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2767       };
2768     }
2769   }
2770
2771   jresult = (void *)result;
2772   return jresult;
2773 }
2774
2775
2776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2777   void * jresult ;
2778   intp *result = 0 ;
2779
2780   {
2781     try {
2782       result = (intp *)new_intp();
2783     } catch (std::out_of_range& e) {
2784       {
2785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2786       };
2787     } catch (std::exception& e) {
2788       {
2789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2790       };
2791     } catch (Dali::DaliException e) {
2792       {
2793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2794       };
2795     } catch (...) {
2796       {
2797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2798       };
2799     }
2800   }
2801
2802   jresult = (void *)result;
2803   return jresult;
2804 }
2805
2806
2807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2808   intp *arg1 = (intp *) 0 ;
2809
2810   arg1 = (intp *)jarg1;
2811   {
2812     try {
2813       delete_intp(arg1);
2814     } catch (std::out_of_range& e) {
2815       {
2816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2817       };
2818     } catch (std::exception& e) {
2819       {
2820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2821       };
2822     } catch (Dali::DaliException e) {
2823       {
2824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2825       };
2826     } catch (...) {
2827       {
2828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2829       };
2830     }
2831   }
2832
2833 }
2834
2835
2836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2837   intp *arg1 = (intp *) 0 ;
2838   int arg2 ;
2839
2840   arg1 = (intp *)jarg1;
2841   arg2 = (int)jarg2;
2842   {
2843     try {
2844       intp_assign(arg1,arg2);
2845     } catch (std::out_of_range& e) {
2846       {
2847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2848       };
2849     } catch (std::exception& e) {
2850       {
2851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2852       };
2853     } catch (Dali::DaliException e) {
2854       {
2855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2856       };
2857     } catch (...) {
2858       {
2859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2860       };
2861     }
2862   }
2863
2864 }
2865
2866
2867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2868   int jresult ;
2869   intp *arg1 = (intp *) 0 ;
2870   int result;
2871
2872   arg1 = (intp *)jarg1;
2873   {
2874     try {
2875       result = (int)intp_value(arg1);
2876     } catch (std::out_of_range& e) {
2877       {
2878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2879       };
2880     } catch (std::exception& e) {
2881       {
2882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2883       };
2884     } catch (Dali::DaliException e) {
2885       {
2886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2887       };
2888     } catch (...) {
2889       {
2890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2891       };
2892     }
2893   }
2894
2895   jresult = result;
2896   return jresult;
2897 }
2898
2899
2900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2901   void * jresult ;
2902   intp *arg1 = (intp *) 0 ;
2903   int *result = 0 ;
2904
2905   arg1 = (intp *)jarg1;
2906   {
2907     try {
2908       result = (int *)intp_cast(arg1);
2909     } catch (std::out_of_range& e) {
2910       {
2911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2912       };
2913     } catch (std::exception& e) {
2914       {
2915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2916       };
2917     } catch (Dali::DaliException e) {
2918       {
2919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2920       };
2921     } catch (...) {
2922       {
2923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2924       };
2925     }
2926   }
2927
2928   jresult = (void *)result;
2929   return jresult;
2930 }
2931
2932
2933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2934   void * jresult ;
2935   int *arg1 = (int *) 0 ;
2936   intp *result = 0 ;
2937
2938   arg1 = (int *)jarg1;
2939   {
2940     try {
2941       result = (intp *)intp_frompointer(arg1);
2942     } catch (std::out_of_range& e) {
2943       {
2944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2945       };
2946     } catch (std::exception& e) {
2947       {
2948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2949       };
2950     } catch (Dali::DaliException e) {
2951       {
2952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2953       };
2954     } catch (...) {
2955       {
2956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2957       };
2958     }
2959   }
2960
2961   jresult = (void *)result;
2962   return jresult;
2963 }
2964
2965
2966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2967   void * jresult ;
2968   doublep *result = 0 ;
2969
2970   {
2971     try {
2972       result = (doublep *)new_doublep();
2973     } catch (std::out_of_range& e) {
2974       {
2975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2976       };
2977     } catch (std::exception& e) {
2978       {
2979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2980       };
2981     } catch (Dali::DaliException e) {
2982       {
2983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2984       };
2985     } catch (...) {
2986       {
2987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2988       };
2989     }
2990   }
2991
2992   jresult = (void *)result;
2993   return jresult;
2994 }
2995
2996
2997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2998   doublep *arg1 = (doublep *) 0 ;
2999
3000   arg1 = (doublep *)jarg1;
3001   {
3002     try {
3003       delete_doublep(arg1);
3004     } catch (std::out_of_range& e) {
3005       {
3006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3007       };
3008     } catch (std::exception& e) {
3009       {
3010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3011       };
3012     } catch (Dali::DaliException e) {
3013       {
3014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3015       };
3016     } catch (...) {
3017       {
3018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3019       };
3020     }
3021   }
3022
3023 }
3024
3025
3026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3027   doublep *arg1 = (doublep *) 0 ;
3028   double arg2 ;
3029
3030   arg1 = (doublep *)jarg1;
3031   arg2 = (double)jarg2;
3032   {
3033     try {
3034       doublep_assign(arg1,arg2);
3035     } catch (std::out_of_range& e) {
3036       {
3037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3038       };
3039     } catch (std::exception& e) {
3040       {
3041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3042       };
3043     } catch (Dali::DaliException e) {
3044       {
3045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3046       };
3047     } catch (...) {
3048       {
3049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3050       };
3051     }
3052   }
3053
3054 }
3055
3056
3057 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3058   double jresult ;
3059   doublep *arg1 = (doublep *) 0 ;
3060   double result;
3061
3062   arg1 = (doublep *)jarg1;
3063   {
3064     try {
3065       result = (double)doublep_value(arg1);
3066     } catch (std::out_of_range& e) {
3067       {
3068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3069       };
3070     } catch (std::exception& e) {
3071       {
3072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3073       };
3074     } catch (Dali::DaliException e) {
3075       {
3076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3077       };
3078     } catch (...) {
3079       {
3080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3081       };
3082     }
3083   }
3084
3085   jresult = result;
3086   return jresult;
3087 }
3088
3089
3090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3091   void * jresult ;
3092   doublep *arg1 = (doublep *) 0 ;
3093   double *result = 0 ;
3094
3095   arg1 = (doublep *)jarg1;
3096   {
3097     try {
3098       result = (double *)doublep_cast(arg1);
3099     } catch (std::out_of_range& e) {
3100       {
3101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3102       };
3103     } catch (std::exception& e) {
3104       {
3105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3106       };
3107     } catch (Dali::DaliException e) {
3108       {
3109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3110       };
3111     } catch (...) {
3112       {
3113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3114       };
3115     }
3116   }
3117
3118   jresult = (void *)result;
3119   return jresult;
3120 }
3121
3122
3123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3124   void * jresult ;
3125   double *arg1 = (double *) 0 ;
3126   doublep *result = 0 ;
3127
3128   arg1 = (double *)jarg1;
3129   {
3130     try {
3131       result = (doublep *)doublep_frompointer(arg1);
3132     } catch (std::out_of_range& e) {
3133       {
3134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3135       };
3136     } catch (std::exception& e) {
3137       {
3138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3139       };
3140     } catch (Dali::DaliException e) {
3141       {
3142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3143       };
3144     } catch (...) {
3145       {
3146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3147       };
3148     }
3149   }
3150
3151   jresult = (void *)result;
3152   return jresult;
3153 }
3154
3155
3156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3157   void * jresult ;
3158   uintp *result = 0 ;
3159
3160   {
3161     try {
3162       result = (uintp *)new_uintp();
3163     } catch (std::out_of_range& e) {
3164       {
3165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3166       };
3167     } catch (std::exception& e) {
3168       {
3169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3170       };
3171     } catch (Dali::DaliException e) {
3172       {
3173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3174       };
3175     } catch (...) {
3176       {
3177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3178       };
3179     }
3180   }
3181
3182   jresult = (void *)result;
3183   return jresult;
3184 }
3185
3186
3187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3188   uintp *arg1 = (uintp *) 0 ;
3189
3190   arg1 = (uintp *)jarg1;
3191   {
3192     try {
3193       delete_uintp(arg1);
3194     } catch (std::out_of_range& e) {
3195       {
3196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3197       };
3198     } catch (std::exception& e) {
3199       {
3200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3201       };
3202     } catch (Dali::DaliException e) {
3203       {
3204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3205       };
3206     } catch (...) {
3207       {
3208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3209       };
3210     }
3211   }
3212
3213 }
3214
3215
3216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3217   uintp *arg1 = (uintp *) 0 ;
3218   unsigned int arg2 ;
3219
3220   arg1 = (uintp *)jarg1;
3221   arg2 = (unsigned int)jarg2;
3222   {
3223     try {
3224       uintp_assign(arg1,arg2);
3225     } catch (std::out_of_range& e) {
3226       {
3227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3228       };
3229     } catch (std::exception& e) {
3230       {
3231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3232       };
3233     } catch (Dali::DaliException e) {
3234       {
3235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3236       };
3237     } catch (...) {
3238       {
3239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3240       };
3241     }
3242   }
3243
3244 }
3245
3246
3247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3248   unsigned int jresult ;
3249   uintp *arg1 = (uintp *) 0 ;
3250   unsigned int result;
3251
3252   arg1 = (uintp *)jarg1;
3253   {
3254     try {
3255       result = (unsigned int)uintp_value(arg1);
3256     } catch (std::out_of_range& e) {
3257       {
3258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3259       };
3260     } catch (std::exception& e) {
3261       {
3262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3263       };
3264     } catch (Dali::DaliException e) {
3265       {
3266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3267       };
3268     } catch (...) {
3269       {
3270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3271       };
3272     }
3273   }
3274
3275   jresult = result;
3276   return jresult;
3277 }
3278
3279
3280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3281   void * jresult ;
3282   uintp *arg1 = (uintp *) 0 ;
3283   unsigned int *result = 0 ;
3284
3285   arg1 = (uintp *)jarg1;
3286   {
3287     try {
3288       result = (unsigned int *)uintp_cast(arg1);
3289     } catch (std::out_of_range& e) {
3290       {
3291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3292       };
3293     } catch (std::exception& e) {
3294       {
3295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3296       };
3297     } catch (Dali::DaliException e) {
3298       {
3299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3300       };
3301     } catch (...) {
3302       {
3303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3304       };
3305     }
3306   }
3307
3308   jresult = (void *)result;
3309   return jresult;
3310 }
3311
3312
3313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3314   void * jresult ;
3315   unsigned int *arg1 = (unsigned int *) 0 ;
3316   uintp *result = 0 ;
3317
3318   arg1 = (unsigned int *)jarg1;
3319   {
3320     try {
3321       result = (uintp *)uintp_frompointer(arg1);
3322     } catch (std::out_of_range& e) {
3323       {
3324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3325       };
3326     } catch (std::exception& e) {
3327       {
3328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3329       };
3330     } catch (Dali::DaliException e) {
3331       {
3332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3333       };
3334     } catch (...) {
3335       {
3336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3337       };
3338     }
3339   }
3340
3341   jresult = (void *)result;
3342   return jresult;
3343 }
3344
3345
3346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3347   void * jresult ;
3348   ushortp *result = 0 ;
3349
3350   {
3351     try {
3352       result = (ushortp *)new_ushortp();
3353     } catch (std::out_of_range& e) {
3354       {
3355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3356       };
3357     } catch (std::exception& e) {
3358       {
3359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3360       };
3361     } catch (Dali::DaliException e) {
3362       {
3363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3364       };
3365     } catch (...) {
3366       {
3367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3368       };
3369     }
3370   }
3371
3372   jresult = (void *)result;
3373   return jresult;
3374 }
3375
3376
3377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3378   ushortp *arg1 = (ushortp *) 0 ;
3379
3380   arg1 = (ushortp *)jarg1;
3381   {
3382     try {
3383       delete_ushortp(arg1);
3384     } catch (std::out_of_range& e) {
3385       {
3386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3387       };
3388     } catch (std::exception& e) {
3389       {
3390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3391       };
3392     } catch (Dali::DaliException e) {
3393       {
3394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3395       };
3396     } catch (...) {
3397       {
3398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3399       };
3400     }
3401   }
3402
3403 }
3404
3405
3406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3407   ushortp *arg1 = (ushortp *) 0 ;
3408   unsigned short arg2 ;
3409
3410   arg1 = (ushortp *)jarg1;
3411   arg2 = (unsigned short)jarg2;
3412   {
3413     try {
3414       ushortp_assign(arg1,arg2);
3415     } catch (std::out_of_range& e) {
3416       {
3417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3418       };
3419     } catch (std::exception& e) {
3420       {
3421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3422       };
3423     } catch (Dali::DaliException e) {
3424       {
3425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3426       };
3427     } catch (...) {
3428       {
3429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3430       };
3431     }
3432   }
3433
3434 }
3435
3436
3437 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3438   unsigned short jresult ;
3439   ushortp *arg1 = (ushortp *) 0 ;
3440   unsigned short result;
3441
3442   arg1 = (ushortp *)jarg1;
3443   {
3444     try {
3445       result = (unsigned short)ushortp_value(arg1);
3446     } catch (std::out_of_range& e) {
3447       {
3448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3449       };
3450     } catch (std::exception& e) {
3451       {
3452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3453       };
3454     } catch (Dali::DaliException e) {
3455       {
3456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3457       };
3458     } catch (...) {
3459       {
3460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3461       };
3462     }
3463   }
3464
3465   jresult = result;
3466   return jresult;
3467 }
3468
3469
3470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3471   void * jresult ;
3472   ushortp *arg1 = (ushortp *) 0 ;
3473   unsigned short *result = 0 ;
3474
3475   arg1 = (ushortp *)jarg1;
3476   {
3477     try {
3478       result = (unsigned short *)ushortp_cast(arg1);
3479     } catch (std::out_of_range& e) {
3480       {
3481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3482       };
3483     } catch (std::exception& e) {
3484       {
3485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3486       };
3487     } catch (Dali::DaliException e) {
3488       {
3489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3490       };
3491     } catch (...) {
3492       {
3493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3494       };
3495     }
3496   }
3497
3498   jresult = (void *)result;
3499   return jresult;
3500 }
3501
3502
3503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3504   void * jresult ;
3505   unsigned short *arg1 = (unsigned short *) 0 ;
3506   ushortp *result = 0 ;
3507
3508   arg1 = (unsigned short *)jarg1;
3509   {
3510     try {
3511       result = (ushortp *)ushortp_frompointer(arg1);
3512     } catch (std::out_of_range& e) {
3513       {
3514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3515       };
3516     } catch (std::exception& e) {
3517       {
3518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3519       };
3520     } catch (Dali::DaliException e) {
3521       {
3522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3523       };
3524     } catch (...) {
3525       {
3526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3527       };
3528     }
3529   }
3530
3531   jresult = (void *)result;
3532   return jresult;
3533 }
3534
3535
3536 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3537   unsigned int jresult ;
3538   int arg1 ;
3539   unsigned int result;
3540
3541   arg1 = (int)jarg1;
3542   {
3543     try {
3544       result = (unsigned int)int_to_uint(arg1);
3545     } catch (std::out_of_range& e) {
3546       {
3547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3548       };
3549     } catch (std::exception& e) {
3550       {
3551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3552       };
3553     } catch (Dali::DaliException e) {
3554       {
3555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3556       };
3557     } catch (...) {
3558       {
3559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3560       };
3561     }
3562   }
3563
3564   jresult = result;
3565   return jresult;
3566 }
3567
3568
3569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3570   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3571
3572   arg1 = (Dali::RefObject *)jarg1;
3573   {
3574     try {
3575       (arg1)->Reference();
3576     } catch (std::out_of_range& e) {
3577       {
3578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3579       };
3580     } catch (std::exception& e) {
3581       {
3582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3583       };
3584     } catch (Dali::DaliException e) {
3585       {
3586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3587       };
3588     } catch (...) {
3589       {
3590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3591       };
3592     }
3593   }
3594
3595 }
3596
3597
3598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3599   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3600
3601   arg1 = (Dali::RefObject *)jarg1;
3602   {
3603     try {
3604       (arg1)->Unreference();
3605     } catch (std::out_of_range& e) {
3606       {
3607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3608       };
3609     } catch (std::exception& e) {
3610       {
3611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3612       };
3613     } catch (Dali::DaliException e) {
3614       {
3615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3616       };
3617     } catch (...) {
3618       {
3619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3620       };
3621     }
3622   }
3623
3624 }
3625
3626
3627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3628   int jresult ;
3629   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3630   int result;
3631
3632   arg1 = (Dali::RefObject *)jarg1;
3633   {
3634     try {
3635       result = (int)(arg1)->ReferenceCount();
3636     } catch (std::out_of_range& e) {
3637       {
3638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3639       };
3640     } catch (std::exception& e) {
3641       {
3642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3643       };
3644     } catch (Dali::DaliException e) {
3645       {
3646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3647       };
3648     } catch (...) {
3649       {
3650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3651       };
3652     }
3653   }
3654
3655   jresult = result;
3656   return jresult;
3657 }
3658
3659
3660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3661   void * jresult ;
3662   Dali::Any *result = 0 ;
3663
3664   {
3665     try {
3666       result = (Dali::Any *)new Dali::Any();
3667     } catch (std::out_of_range& e) {
3668       {
3669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3670       };
3671     } catch (std::exception& e) {
3672       {
3673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3674       };
3675     } catch (Dali::DaliException e) {
3676       {
3677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3678       };
3679     } catch (...) {
3680       {
3681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3682       };
3683     }
3684   }
3685
3686   jresult = (void *)result;
3687   return jresult;
3688 }
3689
3690
3691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3692   Dali::Any *arg1 = (Dali::Any *) 0 ;
3693
3694   arg1 = (Dali::Any *)jarg1;
3695   {
3696     try {
3697       delete arg1;
3698     } catch (std::out_of_range& e) {
3699       {
3700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3701       };
3702     } catch (std::exception& e) {
3703       {
3704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3705       };
3706     } catch (Dali::DaliException e) {
3707       {
3708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3709       };
3710     } catch (...) {
3711       {
3712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3713       };
3714     }
3715   }
3716
3717 }
3718
3719
3720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3721   char *arg1 = (char *) 0 ;
3722
3723   arg1 = (char *)jarg1;
3724   {
3725     try {
3726       Dali::Any::AssertAlways((char const *)arg1);
3727     } catch (std::out_of_range& e) {
3728       {
3729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3730       };
3731     } catch (std::exception& e) {
3732       {
3733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3734       };
3735     } catch (Dali::DaliException e) {
3736       {
3737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3738       };
3739     } catch (...) {
3740       {
3741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3742       };
3743     }
3744   }
3745
3746 }
3747
3748
3749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3750   void * jresult ;
3751   Dali::Any *arg1 = 0 ;
3752   Dali::Any *result = 0 ;
3753
3754   arg1 = (Dali::Any *)jarg1;
3755   if (!arg1) {
3756     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3757     return 0;
3758   }
3759   {
3760     try {
3761       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3762     } catch (std::out_of_range& e) {
3763       {
3764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3765       };
3766     } catch (std::exception& e) {
3767       {
3768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3769       };
3770     } catch (Dali::DaliException e) {
3771       {
3772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3773       };
3774     } catch (...) {
3775       {
3776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3777       };
3778     }
3779   }
3780
3781   jresult = (void *)result;
3782   return jresult;
3783 }
3784
3785
3786 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3787   void * jresult ;
3788   Dali::Any *arg1 = (Dali::Any *) 0 ;
3789   Dali::Any *arg2 = 0 ;
3790   Dali::Any *result = 0 ;
3791
3792   arg1 = (Dali::Any *)jarg1;
3793   arg2 = (Dali::Any *)jarg2;
3794   if (!arg2) {
3795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3796     return 0;
3797   }
3798   {
3799     try {
3800       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3801     } catch (std::out_of_range& e) {
3802       {
3803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3804       };
3805     } catch (std::exception& e) {
3806       {
3807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3808       };
3809     } catch (Dali::DaliException e) {
3810       {
3811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3812       };
3813     } catch (...) {
3814       {
3815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3816       };
3817     }
3818   }
3819
3820   jresult = (void *)result;
3821   return jresult;
3822 }
3823
3824
3825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3826   void * jresult ;
3827   Dali::Any *arg1 = (Dali::Any *) 0 ;
3828   std::type_info *result = 0 ;
3829
3830   arg1 = (Dali::Any *)jarg1;
3831   {
3832     try {
3833       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3834     } catch (std::out_of_range& e) {
3835       {
3836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3837       };
3838     } catch (std::exception& e) {
3839       {
3840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3841       };
3842     } catch (Dali::DaliException e) {
3843       {
3844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3845       };
3846     } catch (...) {
3847       {
3848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3849       };
3850     }
3851   }
3852
3853   jresult = (void *)result;
3854   return jresult;
3855 }
3856
3857
3858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3859   unsigned int jresult ;
3860   Dali::Any *arg1 = (Dali::Any *) 0 ;
3861   bool result;
3862
3863   arg1 = (Dali::Any *)jarg1;
3864   {
3865     try {
3866       result = (bool)((Dali::Any const *)arg1)->Empty();
3867     } catch (std::out_of_range& e) {
3868       {
3869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3870       };
3871     } catch (std::exception& e) {
3872       {
3873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3874       };
3875     } catch (Dali::DaliException e) {
3876       {
3877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3878       };
3879     } catch (...) {
3880       {
3881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3882       };
3883     }
3884   }
3885
3886   jresult = result;
3887   return jresult;
3888 }
3889
3890
3891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3892   void * jresult ;
3893   std::type_info *arg1 = 0 ;
3894   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3895   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3896   Dali::Any::AnyContainerBase *result = 0 ;
3897
3898   arg1 = (std::type_info *)jarg1;
3899   if (!arg1) {
3900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3901     return 0;
3902   }
3903   arg2 = (Dali::Any::CloneFunc)jarg2;
3904   arg3 = (Dali::Any::DeleteFunc)jarg3;
3905   {
3906     try {
3907       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3908     } catch (std::out_of_range& e) {
3909       {
3910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3911       };
3912     } catch (std::exception& e) {
3913       {
3914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3915       };
3916     } catch (Dali::DaliException e) {
3917       {
3918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3919       };
3920     } catch (...) {
3921       {
3922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3923       };
3924     }
3925   }
3926
3927   jresult = (void *)result;
3928   return jresult;
3929 }
3930
3931
3932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3933   void * jresult ;
3934   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3935   std::type_info *result = 0 ;
3936
3937   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3938   {
3939     try {
3940       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3941     } catch (std::out_of_range& e) {
3942       {
3943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3944       };
3945     } catch (std::exception& e) {
3946       {
3947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3948       };
3949     } catch (Dali::DaliException e) {
3950       {
3951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3952       };
3953     } catch (...) {
3954       {
3955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3956       };
3957     }
3958   }
3959
3960   jresult = (void *)result;
3961   return jresult;
3962 }
3963
3964
3965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3966   void * jresult ;
3967   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3968   ::std::type_info *result = 0 ;
3969
3970   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3971   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3972   jresult = (void *)result;
3973   return jresult;
3974 }
3975
3976
3977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3978   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3979   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3980
3981   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3982   arg2 = (Dali::Any::CloneFunc)jarg2;
3983   if (arg1) (arg1)->mCloneFunc = arg2;
3984 }
3985
3986
3987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3988   void * jresult ;
3989   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3990   Dali::Any::CloneFunc result;
3991
3992   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3993   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3994   jresult = (void *)result;
3995   return jresult;
3996 }
3997
3998
3999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4000   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4001   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4002
4003   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4004   arg2 = (Dali::Any::DeleteFunc)jarg2;
4005   if (arg1) (arg1)->mDeleteFunc = arg2;
4006 }
4007
4008
4009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4010   void * jresult ;
4011   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4012   Dali::Any::DeleteFunc result;
4013
4014   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4015   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4016   jresult = (void *)result;
4017   return jresult;
4018 }
4019
4020
4021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4022   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4023
4024   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4025   {
4026     try {
4027       delete arg1;
4028     } catch (std::out_of_range& e) {
4029       {
4030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4031       };
4032     } catch (std::exception& e) {
4033       {
4034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4035       };
4036     } catch (Dali::DaliException e) {
4037       {
4038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4039       };
4040     } catch (...) {
4041       {
4042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4043       };
4044     }
4045   }
4046
4047 }
4048
4049
4050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4051   Dali::Any *arg1 = (Dali::Any *) 0 ;
4052   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4053
4054   arg1 = (Dali::Any *)jarg1;
4055   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4056   if (arg1) (arg1)->mContainer = arg2;
4057 }
4058
4059
4060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4061   void * jresult ;
4062   Dali::Any *arg1 = (Dali::Any *) 0 ;
4063   Dali::Any::AnyContainerBase *result = 0 ;
4064
4065   arg1 = (Dali::Any *)jarg1;
4066   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4067   jresult = (void *)result;
4068   return jresult;
4069 }
4070
4071
4072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4073   char *arg1 = (char *) 0 ;
4074   char *arg2 = (char *) 0 ;
4075
4076   arg1 = (char *)jarg1;
4077   arg2 = (char *)jarg2;
4078   {
4079     try {
4080       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4081     } catch (std::out_of_range& e) {
4082       {
4083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4084       };
4085     } catch (std::exception& e) {
4086       {
4087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4088       };
4089     } catch (Dali::DaliException e) {
4090       {
4091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4092       };
4093     } catch (...) {
4094       {
4095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4096       };
4097     }
4098   }
4099
4100 }
4101
4102
4103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4104   void * jresult ;
4105   char *arg1 = (char *) 0 ;
4106   char *arg2 = (char *) 0 ;
4107   Dali::DaliException *result = 0 ;
4108
4109   arg1 = (char *)jarg1;
4110   arg2 = (char *)jarg2;
4111   {
4112     try {
4113       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4114     } catch (std::out_of_range& e) {
4115       {
4116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4117       };
4118     } catch (std::exception& e) {
4119       {
4120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4121       };
4122     } catch (Dali::DaliException e) {
4123       {
4124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4125       };
4126     } catch (...) {
4127       {
4128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4129       };
4130     }
4131   }
4132
4133   jresult = (void *)result;
4134   return jresult;
4135 }
4136
4137
4138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4139   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4140   std::string arg2 = std::string(jarg2);
4141
4142   arg1 = (Dali::DaliException *)jarg1;
4143   {
4144     if (!arg2.empty()) {
4145       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4146     } else {
4147       arg1->location = 0;
4148     }
4149   }
4150 }
4151
4152 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4153   char * jresult ;
4154   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4155   char *result = 0 ;
4156
4157   arg1 = (Dali::DaliException *)jarg1;
4158   result = (char *) ((arg1)->location);
4159   jresult = SWIG_csharp_string_callback((const char *)result);
4160   return jresult;
4161 }
4162
4163
4164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4165   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4166   std::string arg2 = std::string(jarg2);
4167
4168   arg1 = (Dali::DaliException *)jarg1;
4169   {
4170     if (!arg2.empty()) {
4171       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4172     } else {
4173       arg1->condition = 0;
4174     }
4175   }
4176 }
4177
4178
4179 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4180   char * jresult ;
4181   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4182   char *result = 0 ;
4183
4184   arg1 = (Dali::DaliException *)jarg1;
4185   result = (char *) ((arg1)->condition);
4186   jresult = SWIG_csharp_string_callback((const char *)result);
4187   return jresult;
4188 }
4189
4190
4191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4192   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4193
4194   arg1 = (Dali::DaliException *)jarg1;
4195   {
4196     try {
4197       delete arg1;
4198     } catch (std::out_of_range& e) {
4199       {
4200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4201       };
4202     } catch (std::exception& e) {
4203       {
4204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4205       };
4206     } catch (Dali::DaliException e) {
4207       {
4208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4209       };
4210     } catch (...) {
4211       {
4212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4213       };
4214     }
4215   }
4216
4217 }
4218
4219
4220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4221   void * jresult ;
4222   Dali::Vector2 *result = 0 ;
4223
4224   {
4225     try {
4226       result = (Dali::Vector2 *)new Dali::Vector2();
4227     } catch (std::out_of_range& e) {
4228       {
4229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4230       };
4231     } catch (std::exception& e) {
4232       {
4233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4234       };
4235     } catch (Dali::DaliException e) {
4236       {
4237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4238       };
4239     } catch (...) {
4240       {
4241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4242       };
4243     }
4244   }
4245
4246   jresult = (void *)result;
4247   return jresult;
4248 }
4249
4250
4251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4252   void * jresult ;
4253   float arg1 ;
4254   float arg2 ;
4255   Dali::Vector2 *result = 0 ;
4256
4257   arg1 = (float)jarg1;
4258   arg2 = (float)jarg2;
4259   {
4260     try {
4261       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4262     } catch (std::out_of_range& e) {
4263       {
4264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4265       };
4266     } catch (std::exception& e) {
4267       {
4268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4269       };
4270     } catch (Dali::DaliException e) {
4271       {
4272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4273       };
4274     } catch (...) {
4275       {
4276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4277       };
4278     }
4279   }
4280
4281   jresult = (void *)result;
4282   return jresult;
4283 }
4284
4285
4286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4287   void * jresult ;
4288   float *arg1 = (float *) 0 ;
4289   Dali::Vector2 *result = 0 ;
4290
4291   arg1 = jarg1;
4292   {
4293     try {
4294       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4295     } catch (std::out_of_range& e) {
4296       {
4297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4298       };
4299     } catch (std::exception& e) {
4300       {
4301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4302       };
4303     } catch (Dali::DaliException e) {
4304       {
4305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4306       };
4307     } catch (...) {
4308       {
4309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4310       };
4311     }
4312   }
4313
4314   jresult = (void *)result;
4315
4316
4317   return jresult;
4318 }
4319
4320
4321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4322   void * jresult ;
4323   Dali::Vector3 *arg1 = 0 ;
4324   Dali::Vector2 *result = 0 ;
4325
4326   arg1 = (Dali::Vector3 *)jarg1;
4327   if (!arg1) {
4328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4329     return 0;
4330   }
4331   {
4332     try {
4333       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4334     } catch (std::out_of_range& e) {
4335       {
4336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4337       };
4338     } catch (std::exception& e) {
4339       {
4340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4341       };
4342     } catch (Dali::DaliException e) {
4343       {
4344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4345       };
4346     } catch (...) {
4347       {
4348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4349       };
4350     }
4351   }
4352
4353   jresult = (void *)result;
4354   return jresult;
4355 }
4356
4357
4358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4359   void * jresult ;
4360   Dali::Vector4 *arg1 = 0 ;
4361   Dali::Vector2 *result = 0 ;
4362
4363   arg1 = (Dali::Vector4 *)jarg1;
4364   if (!arg1) {
4365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4366     return 0;
4367   }
4368   {
4369     try {
4370       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4371     } catch (std::out_of_range& e) {
4372       {
4373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4374       };
4375     } catch (std::exception& e) {
4376       {
4377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4378       };
4379     } catch (Dali::DaliException e) {
4380       {
4381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4382       };
4383     } catch (...) {
4384       {
4385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4386       };
4387     }
4388   }
4389
4390   jresult = (void *)result;
4391   return jresult;
4392 }
4393
4394
4395 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4396   void * jresult ;
4397   Dali::Vector2 *result = 0 ;
4398
4399   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4400   jresult = (void *)result;
4401   return jresult;
4402 }
4403
4404
4405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4406   void * jresult ;
4407   Dali::Vector2 *result = 0 ;
4408
4409   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4410   jresult = (void *)result;
4411   return jresult;
4412 }
4413
4414
4415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4416   void * jresult ;
4417   Dali::Vector2 *result = 0 ;
4418
4419   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4420   jresult = (void *)result;
4421   return jresult;
4422 }
4423
4424
4425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4426   void * jresult ;
4427   Dali::Vector2 *result = 0 ;
4428
4429   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4430   jresult = (void *)result;
4431   return jresult;
4432 }
4433
4434
4435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4436   void * jresult ;
4437   Dali::Vector2 *result = 0 ;
4438
4439   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4440   jresult = (void *)result;
4441   return jresult;
4442 }
4443
4444
4445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4446   void * jresult ;
4447   Dali::Vector2 *result = 0 ;
4448
4449   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4450   jresult = (void *)result;
4451   return jresult;
4452 }
4453
4454
4455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4456   void * jresult ;
4457   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4458   float *arg2 = (float *) 0 ;
4459   Dali::Vector2 *result = 0 ;
4460
4461   arg1 = (Dali::Vector2 *)jarg1;
4462   arg2 = jarg2;
4463   {
4464     try {
4465       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4466     } catch (std::out_of_range& e) {
4467       {
4468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4469       };
4470     } catch (std::exception& e) {
4471       {
4472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4473       };
4474     } catch (Dali::DaliException e) {
4475       {
4476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4477       };
4478     } catch (...) {
4479       {
4480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4481       };
4482     }
4483   }
4484
4485   jresult = (void *)result;
4486
4487
4488   return jresult;
4489 }
4490
4491
4492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4493   void * jresult ;
4494   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4495   Dali::Vector3 *arg2 = 0 ;
4496   Dali::Vector2 *result = 0 ;
4497
4498   arg1 = (Dali::Vector2 *)jarg1;
4499   arg2 = (Dali::Vector3 *)jarg2;
4500   if (!arg2) {
4501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4502     return 0;
4503   }
4504   {
4505     try {
4506       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4507     } catch (std::out_of_range& e) {
4508       {
4509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4510       };
4511     } catch (std::exception& e) {
4512       {
4513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4514       };
4515     } catch (Dali::DaliException e) {
4516       {
4517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4518       };
4519     } catch (...) {
4520       {
4521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4522       };
4523     }
4524   }
4525
4526   jresult = (void *)result;
4527   return jresult;
4528 }
4529
4530
4531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4532   void * jresult ;
4533   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4534   Dali::Vector4 *arg2 = 0 ;
4535   Dali::Vector2 *result = 0 ;
4536
4537   arg1 = (Dali::Vector2 *)jarg1;
4538   arg2 = (Dali::Vector4 *)jarg2;
4539   if (!arg2) {
4540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4541     return 0;
4542   }
4543   {
4544     try {
4545       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4546     } catch (std::out_of_range& e) {
4547       {
4548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4549       };
4550     } catch (std::exception& e) {
4551       {
4552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4553       };
4554     } catch (Dali::DaliException e) {
4555       {
4556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4557       };
4558     } catch (...) {
4559       {
4560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4561       };
4562     }
4563   }
4564
4565   jresult = (void *)result;
4566   return jresult;
4567 }
4568
4569
4570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4571   void * jresult ;
4572   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4573   Dali::Vector2 *arg2 = 0 ;
4574   Dali::Vector2 result;
4575
4576   arg1 = (Dali::Vector2 *)jarg1;
4577   arg2 = (Dali::Vector2 *)jarg2;
4578   if (!arg2) {
4579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4580     return 0;
4581   }
4582   {
4583     try {
4584       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4585     } catch (std::out_of_range& e) {
4586       {
4587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4588       };
4589     } catch (std::exception& e) {
4590       {
4591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4592       };
4593     } catch (Dali::DaliException e) {
4594       {
4595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4596       };
4597     } catch (...) {
4598       {
4599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4600       };
4601     }
4602   }
4603
4604   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4605   return jresult;
4606 }
4607
4608
4609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4610   void * jresult ;
4611   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4612   Dali::Vector2 *arg2 = 0 ;
4613   Dali::Vector2 *result = 0 ;
4614
4615   arg1 = (Dali::Vector2 *)jarg1;
4616   arg2 = (Dali::Vector2 *)jarg2;
4617   if (!arg2) {
4618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4619     return 0;
4620   }
4621   {
4622     try {
4623       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4624     } catch (std::out_of_range& e) {
4625       {
4626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4627       };
4628     } catch (std::exception& e) {
4629       {
4630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4631       };
4632     } catch (Dali::DaliException e) {
4633       {
4634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4635       };
4636     } catch (...) {
4637       {
4638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4639       };
4640     }
4641   }
4642
4643   jresult = (void *)result;
4644   return jresult;
4645 }
4646
4647
4648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4649   void * jresult ;
4650   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4651   Dali::Vector2 *arg2 = 0 ;
4652   Dali::Vector2 result;
4653
4654   arg1 = (Dali::Vector2 *)jarg1;
4655   arg2 = (Dali::Vector2 *)jarg2;
4656   if (!arg2) {
4657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4658     return 0;
4659   }
4660   {
4661     try {
4662       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4663     } catch (std::out_of_range& e) {
4664       {
4665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4666       };
4667     } catch (std::exception& e) {
4668       {
4669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4670       };
4671     } catch (Dali::DaliException e) {
4672       {
4673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4674       };
4675     } catch (...) {
4676       {
4677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4678       };
4679     }
4680   }
4681
4682   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4683   return jresult;
4684 }
4685
4686
4687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4688   void * jresult ;
4689   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4690   Dali::Vector2 *arg2 = 0 ;
4691   Dali::Vector2 *result = 0 ;
4692
4693   arg1 = (Dali::Vector2 *)jarg1;
4694   arg2 = (Dali::Vector2 *)jarg2;
4695   if (!arg2) {
4696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4697     return 0;
4698   }
4699   {
4700     try {
4701       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4702     } catch (std::out_of_range& e) {
4703       {
4704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4705       };
4706     } catch (std::exception& e) {
4707       {
4708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4709       };
4710     } catch (Dali::DaliException e) {
4711       {
4712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4713       };
4714     } catch (...) {
4715       {
4716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4717       };
4718     }
4719   }
4720
4721   jresult = (void *)result;
4722   return jresult;
4723 }
4724
4725
4726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4727   void * jresult ;
4728   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4729   Dali::Vector2 *arg2 = 0 ;
4730   Dali::Vector2 result;
4731
4732   arg1 = (Dali::Vector2 *)jarg1;
4733   arg2 = (Dali::Vector2 *)jarg2;
4734   if (!arg2) {
4735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4736     return 0;
4737   }
4738   {
4739     try {
4740       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4741     } catch (std::out_of_range& e) {
4742       {
4743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4744       };
4745     } catch (std::exception& e) {
4746       {
4747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4748       };
4749     } catch (Dali::DaliException e) {
4750       {
4751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4752       };
4753     } catch (...) {
4754       {
4755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4756       };
4757     }
4758   }
4759
4760   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4761   return jresult;
4762 }
4763
4764
4765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4766   void * jresult ;
4767   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4768   float arg2 ;
4769   Dali::Vector2 result;
4770
4771   arg1 = (Dali::Vector2 *)jarg1;
4772   arg2 = (float)jarg2;
4773   {
4774     try {
4775       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4776     } catch (std::out_of_range& e) {
4777       {
4778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4779       };
4780     } catch (std::exception& e) {
4781       {
4782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4783       };
4784     } catch (Dali::DaliException e) {
4785       {
4786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4787       };
4788     } catch (...) {
4789       {
4790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4791       };
4792     }
4793   }
4794
4795   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4796   return jresult;
4797 }
4798
4799
4800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4801   void * jresult ;
4802   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4803   Dali::Vector2 *arg2 = 0 ;
4804   Dali::Vector2 *result = 0 ;
4805
4806   arg1 = (Dali::Vector2 *)jarg1;
4807   arg2 = (Dali::Vector2 *)jarg2;
4808   if (!arg2) {
4809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4810     return 0;
4811   }
4812   {
4813     try {
4814       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4815     } catch (std::out_of_range& e) {
4816       {
4817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4818       };
4819     } catch (std::exception& e) {
4820       {
4821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4822       };
4823     } catch (Dali::DaliException e) {
4824       {
4825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4826       };
4827     } catch (...) {
4828       {
4829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4830       };
4831     }
4832   }
4833
4834   jresult = (void *)result;
4835   return jresult;
4836 }
4837
4838
4839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4840   void * jresult ;
4841   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4842   float arg2 ;
4843   Dali::Vector2 *result = 0 ;
4844
4845   arg1 = (Dali::Vector2 *)jarg1;
4846   arg2 = (float)jarg2;
4847   {
4848     try {
4849       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4850     } catch (std::out_of_range& e) {
4851       {
4852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4853       };
4854     } catch (std::exception& e) {
4855       {
4856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4857       };
4858     } catch (Dali::DaliException e) {
4859       {
4860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4861       };
4862     } catch (...) {
4863       {
4864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4865       };
4866     }
4867   }
4868
4869   jresult = (void *)result;
4870   return jresult;
4871 }
4872
4873
4874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4875   void * jresult ;
4876   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4877   Dali::Vector2 *arg2 = 0 ;
4878   Dali::Vector2 result;
4879
4880   arg1 = (Dali::Vector2 *)jarg1;
4881   arg2 = (Dali::Vector2 *)jarg2;
4882   if (!arg2) {
4883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4884     return 0;
4885   }
4886   {
4887     try {
4888       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4889     } catch (std::out_of_range& e) {
4890       {
4891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4892       };
4893     } catch (std::exception& e) {
4894       {
4895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4896       };
4897     } catch (Dali::DaliException e) {
4898       {
4899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4900       };
4901     } catch (...) {
4902       {
4903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4904       };
4905     }
4906   }
4907
4908   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4909   return jresult;
4910 }
4911
4912
4913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4914   void * jresult ;
4915   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4916   float arg2 ;
4917   Dali::Vector2 result;
4918
4919   arg1 = (Dali::Vector2 *)jarg1;
4920   arg2 = (float)jarg2;
4921   {
4922     try {
4923       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4924     } catch (std::out_of_range& e) {
4925       {
4926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4927       };
4928     } catch (std::exception& e) {
4929       {
4930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4931       };
4932     } catch (Dali::DaliException e) {
4933       {
4934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4935       };
4936     } catch (...) {
4937       {
4938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4939       };
4940     }
4941   }
4942
4943   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4944   return jresult;
4945 }
4946
4947
4948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4949   void * jresult ;
4950   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4951   Dali::Vector2 *arg2 = 0 ;
4952   Dali::Vector2 *result = 0 ;
4953
4954   arg1 = (Dali::Vector2 *)jarg1;
4955   arg2 = (Dali::Vector2 *)jarg2;
4956   if (!arg2) {
4957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4958     return 0;
4959   }
4960   {
4961     try {
4962       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4963     } catch (std::out_of_range& e) {
4964       {
4965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4966       };
4967     } catch (std::exception& e) {
4968       {
4969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4970       };
4971     } catch (Dali::DaliException e) {
4972       {
4973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4974       };
4975     } catch (...) {
4976       {
4977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4978       };
4979     }
4980   }
4981
4982   jresult = (void *)result;
4983   return jresult;
4984 }
4985
4986
4987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4988   void * jresult ;
4989   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4990   float arg2 ;
4991   Dali::Vector2 *result = 0 ;
4992
4993   arg1 = (Dali::Vector2 *)jarg1;
4994   arg2 = (float)jarg2;
4995   {
4996     try {
4997       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4998     } catch (std::out_of_range& e) {
4999       {
5000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5001       };
5002     } catch (std::exception& e) {
5003       {
5004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5005       };
5006     } catch (Dali::DaliException e) {
5007       {
5008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5009       };
5010     } catch (...) {
5011       {
5012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5013       };
5014     }
5015   }
5016
5017   jresult = (void *)result;
5018   return jresult;
5019 }
5020
5021
5022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5023   void * jresult ;
5024   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5025   Dali::Vector2 result;
5026
5027   arg1 = (Dali::Vector2 *)jarg1;
5028   {
5029     try {
5030       result = ((Dali::Vector2 const *)arg1)->operator -();
5031     } catch (std::out_of_range& e) {
5032       {
5033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5034       };
5035     } catch (std::exception& e) {
5036       {
5037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5038       };
5039     } catch (Dali::DaliException e) {
5040       {
5041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5042       };
5043     } catch (...) {
5044       {
5045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5046       };
5047     }
5048   }
5049
5050   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5051   return jresult;
5052 }
5053
5054
5055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5056   unsigned int jresult ;
5057   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5058   Dali::Vector2 *arg2 = 0 ;
5059   bool result;
5060
5061   arg1 = (Dali::Vector2 *)jarg1;
5062   arg2 = (Dali::Vector2 *)jarg2;
5063   if (!arg2) {
5064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5065     return 0;
5066   }
5067   {
5068     try {
5069       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5070     } catch (std::out_of_range& e) {
5071       {
5072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5073       };
5074     } catch (std::exception& e) {
5075       {
5076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5077       };
5078     } catch (Dali::DaliException e) {
5079       {
5080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5081       };
5082     } catch (...) {
5083       {
5084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5085       };
5086     }
5087   }
5088
5089   jresult = result;
5090   return jresult;
5091 }
5092
5093
5094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5095   unsigned int jresult ;
5096   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5097   Dali::Vector2 *arg2 = 0 ;
5098   bool result;
5099
5100   arg1 = (Dali::Vector2 *)jarg1;
5101   arg2 = (Dali::Vector2 *)jarg2;
5102   if (!arg2) {
5103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5104     return 0;
5105   }
5106   {
5107     try {
5108       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5109     } catch (std::out_of_range& e) {
5110       {
5111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5112       };
5113     } catch (std::exception& e) {
5114       {
5115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5116       };
5117     } catch (Dali::DaliException e) {
5118       {
5119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5120       };
5121     } catch (...) {
5122       {
5123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5124       };
5125     }
5126   }
5127
5128   jresult = result;
5129   return jresult;
5130 }
5131
5132
5133 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5134   float jresult ;
5135   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5136   unsigned int arg2 ;
5137   float *result = 0 ;
5138
5139   arg1 = (Dali::Vector2 *)jarg1;
5140   arg2 = (unsigned int)jarg2;
5141   {
5142     try {
5143       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5144     } catch (std::out_of_range& e) {
5145       {
5146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5147       };
5148     } catch (std::exception& e) {
5149       {
5150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5151       };
5152     } catch (Dali::DaliException e) {
5153       {
5154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5155       };
5156     } catch (...) {
5157       {
5158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5159       };
5160     }
5161   }
5162
5163   jresult = *result;
5164   return jresult;
5165 }
5166
5167
5168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5169   float jresult ;
5170   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5171   float result;
5172
5173   arg1 = (Dali::Vector2 *)jarg1;
5174   {
5175     try {
5176       result = (float)((Dali::Vector2 const *)arg1)->Length();
5177     } catch (std::out_of_range& e) {
5178       {
5179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5180       };
5181     } catch (std::exception& e) {
5182       {
5183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5184       };
5185     } catch (Dali::DaliException e) {
5186       {
5187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5188       };
5189     } catch (...) {
5190       {
5191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5192       };
5193     }
5194   }
5195
5196   jresult = result;
5197   return jresult;
5198 }
5199
5200
5201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5202   float jresult ;
5203   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5204   float result;
5205
5206   arg1 = (Dali::Vector2 *)jarg1;
5207   {
5208     try {
5209       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5210     } catch (std::out_of_range& e) {
5211       {
5212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5213       };
5214     } catch (std::exception& e) {
5215       {
5216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5217       };
5218     } catch (Dali::DaliException e) {
5219       {
5220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5221       };
5222     } catch (...) {
5223       {
5224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5225       };
5226     }
5227   }
5228
5229   jresult = result;
5230   return jresult;
5231 }
5232
5233
5234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5235   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5236
5237   arg1 = (Dali::Vector2 *)jarg1;
5238   {
5239     try {
5240       (arg1)->Normalize();
5241     } catch (std::out_of_range& e) {
5242       {
5243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5244       };
5245     } catch (std::exception& e) {
5246       {
5247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5248       };
5249     } catch (Dali::DaliException e) {
5250       {
5251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5252       };
5253     } catch (...) {
5254       {
5255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5256       };
5257     }
5258   }
5259
5260 }
5261
5262
5263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5264   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5265   Dali::Vector2 *arg2 = 0 ;
5266   Dali::Vector2 *arg3 = 0 ;
5267
5268   arg1 = (Dali::Vector2 *)jarg1;
5269   arg2 = (Dali::Vector2 *)jarg2;
5270   if (!arg2) {
5271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5272     return ;
5273   }
5274   arg3 = (Dali::Vector2 *)jarg3;
5275   if (!arg3) {
5276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5277     return ;
5278   }
5279   {
5280     try {
5281       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5282     } catch (std::out_of_range& e) {
5283       {
5284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5285       };
5286     } catch (std::exception& e) {
5287       {
5288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5289       };
5290     } catch (Dali::DaliException e) {
5291       {
5292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5293       };
5294     } catch (...) {
5295       {
5296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5297       };
5298     }
5299   }
5300
5301 }
5302
5303
5304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5305   void * jresult ;
5306   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5307   float *result = 0 ;
5308
5309   arg1 = (Dali::Vector2 *)jarg1;
5310   {
5311     try {
5312       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5313     } catch (std::out_of_range& e) {
5314       {
5315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5316       };
5317     } catch (std::exception& e) {
5318       {
5319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5320       };
5321     } catch (Dali::DaliException e) {
5322       {
5323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5324       };
5325     } catch (...) {
5326       {
5327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5328       };
5329     }
5330   }
5331
5332   jresult = (void *)result;
5333   return jresult;
5334 }
5335
5336
5337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5338   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5339   float arg2 ;
5340
5341   arg1 = (Dali::Vector2 *)jarg1;
5342   arg2 = (float)jarg2;
5343   if (arg1) (arg1)->x = arg2;
5344 }
5345
5346
5347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5348   float jresult ;
5349   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5350   float result;
5351
5352   arg1 = (Dali::Vector2 *)jarg1;
5353   result = (float) ((arg1)->x);
5354   jresult = result;
5355   return jresult;
5356 }
5357
5358
5359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5360   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5361   float arg2 ;
5362
5363   arg1 = (Dali::Vector2 *)jarg1;
5364   arg2 = (float)jarg2;
5365   if (arg1) (arg1)->width = arg2;
5366 }
5367
5368
5369 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5370   float jresult ;
5371   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5372   float result;
5373
5374   arg1 = (Dali::Vector2 *)jarg1;
5375   result = (float) ((arg1)->width);
5376   jresult = result;
5377   return jresult;
5378 }
5379
5380
5381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5382   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5383   float arg2 ;
5384
5385   arg1 = (Dali::Vector2 *)jarg1;
5386   arg2 = (float)jarg2;
5387   if (arg1) (arg1)->y = arg2;
5388 }
5389
5390
5391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5392   float jresult ;
5393   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5394   float result;
5395
5396   arg1 = (Dali::Vector2 *)jarg1;
5397   result = (float) ((arg1)->y);
5398   jresult = result;
5399   return jresult;
5400 }
5401
5402
5403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5404   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5405   float arg2 ;
5406
5407   arg1 = (Dali::Vector2 *)jarg1;
5408   arg2 = (float)jarg2;
5409   if (arg1) (arg1)->height = arg2;
5410 }
5411
5412
5413 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5414   float jresult ;
5415   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5416   float result;
5417
5418   arg1 = (Dali::Vector2 *)jarg1;
5419   result = (float) ((arg1)->height);
5420   jresult = result;
5421   return jresult;
5422 }
5423
5424
5425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5426   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5427
5428   arg1 = (Dali::Vector2 *)jarg1;
5429   {
5430     try {
5431       delete arg1;
5432     } catch (std::out_of_range& e) {
5433       {
5434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5435       };
5436     } catch (std::exception& e) {
5437       {
5438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5439       };
5440     } catch (Dali::DaliException e) {
5441       {
5442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5443       };
5444     } catch (...) {
5445       {
5446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5447       };
5448     }
5449   }
5450
5451 }
5452
5453
5454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5455   void * jresult ;
5456   Dali::Vector2 *arg1 = 0 ;
5457   Dali::Vector2 *arg2 = 0 ;
5458   Dali::Vector2 result;
5459
5460   arg1 = (Dali::Vector2 *)jarg1;
5461   if (!arg1) {
5462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5463     return 0;
5464   }
5465   arg2 = (Dali::Vector2 *)jarg2;
5466   if (!arg2) {
5467     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5468     return 0;
5469   }
5470   {
5471     try {
5472       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5473     } catch (std::out_of_range& e) {
5474       {
5475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5476       };
5477     } catch (std::exception& e) {
5478       {
5479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5480       };
5481     } catch (Dali::DaliException e) {
5482       {
5483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5484       };
5485     } catch (...) {
5486       {
5487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5488       };
5489     }
5490   }
5491
5492   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5493   return jresult;
5494 }
5495
5496
5497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5498   void * jresult ;
5499   Dali::Vector2 *arg1 = 0 ;
5500   Dali::Vector2 *arg2 = 0 ;
5501   Dali::Vector2 result;
5502
5503   arg1 = (Dali::Vector2 *)jarg1;
5504   if (!arg1) {
5505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5506     return 0;
5507   }
5508   arg2 = (Dali::Vector2 *)jarg2;
5509   if (!arg2) {
5510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5511     return 0;
5512   }
5513   {
5514     try {
5515       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5516     } catch (std::out_of_range& e) {
5517       {
5518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5519       };
5520     } catch (std::exception& e) {
5521       {
5522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5523       };
5524     } catch (Dali::DaliException e) {
5525       {
5526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5527       };
5528     } catch (...) {
5529       {
5530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5531       };
5532     }
5533   }
5534
5535   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5536   return jresult;
5537 }
5538
5539
5540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5541   void * jresult ;
5542   Dali::Vector2 *arg1 = 0 ;
5543   float *arg2 = 0 ;
5544   float *arg3 = 0 ;
5545   float temp2 ;
5546   float temp3 ;
5547   Dali::Vector2 result;
5548
5549   arg1 = (Dali::Vector2 *)jarg1;
5550   if (!arg1) {
5551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5552     return 0;
5553   }
5554   temp2 = (float)jarg2;
5555   arg2 = &temp2;
5556   temp3 = (float)jarg3;
5557   arg3 = &temp3;
5558   {
5559     try {
5560       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5561     } catch (std::out_of_range& e) {
5562       {
5563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5564       };
5565     } catch (std::exception& e) {
5566       {
5567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5568       };
5569     } catch (Dali::DaliException e) {
5570       {
5571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5572       };
5573     } catch (...) {
5574       {
5575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5576       };
5577     }
5578   }
5579
5580   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5581   return jresult;
5582 }
5583
5584
5585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5586   void * jresult ;
5587   Dali::Vector3 *result = 0 ;
5588
5589   {
5590     try {
5591       result = (Dali::Vector3 *)new Dali::Vector3();
5592     } catch (std::out_of_range& e) {
5593       {
5594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5595       };
5596     } catch (std::exception& e) {
5597       {
5598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5599       };
5600     } catch (Dali::DaliException e) {
5601       {
5602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5603       };
5604     } catch (...) {
5605       {
5606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5607       };
5608     }
5609   }
5610
5611   jresult = (void *)result;
5612   return jresult;
5613 }
5614
5615
5616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5617   void * jresult ;
5618   float arg1 ;
5619   float arg2 ;
5620   float arg3 ;
5621   Dali::Vector3 *result = 0 ;
5622
5623   arg1 = (float)jarg1;
5624   arg2 = (float)jarg2;
5625   arg3 = (float)jarg3;
5626   {
5627     try {
5628       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5629     } catch (std::out_of_range& e) {
5630       {
5631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5632       };
5633     } catch (std::exception& e) {
5634       {
5635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5636       };
5637     } catch (Dali::DaliException e) {
5638       {
5639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5640       };
5641     } catch (...) {
5642       {
5643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5644       };
5645     }
5646   }
5647
5648   jresult = (void *)result;
5649   return jresult;
5650 }
5651
5652
5653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5654   void * jresult ;
5655   float *arg1 = (float *) 0 ;
5656   Dali::Vector3 *result = 0 ;
5657
5658   arg1 = jarg1;
5659   {
5660     try {
5661       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5662     } catch (std::out_of_range& e) {
5663       {
5664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5665       };
5666     } catch (std::exception& e) {
5667       {
5668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5669       };
5670     } catch (Dali::DaliException e) {
5671       {
5672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5673       };
5674     } catch (...) {
5675       {
5676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5677       };
5678     }
5679   }
5680
5681   jresult = (void *)result;
5682
5683
5684   return jresult;
5685 }
5686
5687
5688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5689   void * jresult ;
5690   Dali::Vector2 *arg1 = 0 ;
5691   Dali::Vector3 *result = 0 ;
5692
5693   arg1 = (Dali::Vector2 *)jarg1;
5694   if (!arg1) {
5695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5696     return 0;
5697   }
5698   {
5699     try {
5700       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5701     } catch (std::out_of_range& e) {
5702       {
5703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5704       };
5705     } catch (std::exception& e) {
5706       {
5707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5708       };
5709     } catch (Dali::DaliException e) {
5710       {
5711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5712       };
5713     } catch (...) {
5714       {
5715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5716       };
5717     }
5718   }
5719
5720   jresult = (void *)result;
5721   return jresult;
5722 }
5723
5724
5725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5726   void * jresult ;
5727   Dali::Vector4 *arg1 = 0 ;
5728   Dali::Vector3 *result = 0 ;
5729
5730   arg1 = (Dali::Vector4 *)jarg1;
5731   if (!arg1) {
5732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5733     return 0;
5734   }
5735   {
5736     try {
5737       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5738     } catch (std::out_of_range& e) {
5739       {
5740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5741       };
5742     } catch (std::exception& e) {
5743       {
5744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5745       };
5746     } catch (Dali::DaliException e) {
5747       {
5748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5749       };
5750     } catch (...) {
5751       {
5752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5753       };
5754     }
5755   }
5756
5757   jresult = (void *)result;
5758   return jresult;
5759 }
5760
5761
5762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5763   void * jresult ;
5764   Dali::Vector3 *result = 0 ;
5765
5766   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5767   jresult = (void *)result;
5768   return jresult;
5769 }
5770
5771
5772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5773   void * jresult ;
5774   Dali::Vector3 *result = 0 ;
5775
5776   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5777   jresult = (void *)result;
5778   return jresult;
5779 }
5780
5781
5782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5783   void * jresult ;
5784   Dali::Vector3 *result = 0 ;
5785
5786   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5787   jresult = (void *)result;
5788   return jresult;
5789 }
5790
5791
5792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5793   void * jresult ;
5794   Dali::Vector3 *result = 0 ;
5795
5796   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5797   jresult = (void *)result;
5798   return jresult;
5799 }
5800
5801
5802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5803   void * jresult ;
5804   Dali::Vector3 *result = 0 ;
5805
5806   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5807   jresult = (void *)result;
5808   return jresult;
5809 }
5810
5811
5812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5813   void * jresult ;
5814   Dali::Vector3 *result = 0 ;
5815
5816   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5817   jresult = (void *)result;
5818   return jresult;
5819 }
5820
5821
5822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5823   void * jresult ;
5824   Dali::Vector3 *result = 0 ;
5825
5826   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5827   jresult = (void *)result;
5828   return jresult;
5829 }
5830
5831
5832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5833   void * jresult ;
5834   Dali::Vector3 *result = 0 ;
5835
5836   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5837   jresult = (void *)result;
5838   return jresult;
5839 }
5840
5841
5842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5843   void * jresult ;
5844   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5845   float *arg2 = (float *) 0 ;
5846   Dali::Vector3 *result = 0 ;
5847
5848   arg1 = (Dali::Vector3 *)jarg1;
5849   arg2 = jarg2;
5850   {
5851     try {
5852       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5853     } catch (std::out_of_range& e) {
5854       {
5855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5856       };
5857     } catch (std::exception& e) {
5858       {
5859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5860       };
5861     } catch (Dali::DaliException e) {
5862       {
5863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5864       };
5865     } catch (...) {
5866       {
5867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5868       };
5869     }
5870   }
5871
5872   jresult = (void *)result;
5873
5874
5875   return jresult;
5876 }
5877
5878
5879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5880   void * jresult ;
5881   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5882   Dali::Vector2 *arg2 = 0 ;
5883   Dali::Vector3 *result = 0 ;
5884
5885   arg1 = (Dali::Vector3 *)jarg1;
5886   arg2 = (Dali::Vector2 *)jarg2;
5887   if (!arg2) {
5888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5889     return 0;
5890   }
5891   {
5892     try {
5893       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5894     } catch (std::out_of_range& e) {
5895       {
5896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5897       };
5898     } catch (std::exception& e) {
5899       {
5900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5901       };
5902     } catch (Dali::DaliException e) {
5903       {
5904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5905       };
5906     } catch (...) {
5907       {
5908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5909       };
5910     }
5911   }
5912
5913   jresult = (void *)result;
5914   return jresult;
5915 }
5916
5917
5918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5919   void * jresult ;
5920   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5921   Dali::Vector4 *arg2 = 0 ;
5922   Dali::Vector3 *result = 0 ;
5923
5924   arg1 = (Dali::Vector3 *)jarg1;
5925   arg2 = (Dali::Vector4 *)jarg2;
5926   if (!arg2) {
5927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5928     return 0;
5929   }
5930   {
5931     try {
5932       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5933     } catch (std::out_of_range& e) {
5934       {
5935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5936       };
5937     } catch (std::exception& e) {
5938       {
5939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5940       };
5941     } catch (Dali::DaliException e) {
5942       {
5943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5944       };
5945     } catch (...) {
5946       {
5947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5948       };
5949     }
5950   }
5951
5952   jresult = (void *)result;
5953   return jresult;
5954 }
5955
5956
5957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5958   void * jresult ;
5959   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5960   Dali::Vector3 *arg2 = 0 ;
5961   Dali::Vector3 result;
5962
5963   arg1 = (Dali::Vector3 *)jarg1;
5964   arg2 = (Dali::Vector3 *)jarg2;
5965   if (!arg2) {
5966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5967     return 0;
5968   }
5969   {
5970     try {
5971       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5972     } catch (std::out_of_range& e) {
5973       {
5974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5975       };
5976     } catch (std::exception& e) {
5977       {
5978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5979       };
5980     } catch (Dali::DaliException e) {
5981       {
5982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5983       };
5984     } catch (...) {
5985       {
5986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5987       };
5988     }
5989   }
5990
5991   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5992   return jresult;
5993 }
5994
5995
5996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5997   void * jresult ;
5998   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5999   Dali::Vector3 *arg2 = 0 ;
6000   Dali::Vector3 *result = 0 ;
6001
6002   arg1 = (Dali::Vector3 *)jarg1;
6003   arg2 = (Dali::Vector3 *)jarg2;
6004   if (!arg2) {
6005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6006     return 0;
6007   }
6008   {
6009     try {
6010       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6011     } catch (std::out_of_range& e) {
6012       {
6013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6014       };
6015     } catch (std::exception& e) {
6016       {
6017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6018       };
6019     } catch (Dali::DaliException e) {
6020       {
6021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6022       };
6023     } catch (...) {
6024       {
6025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6026       };
6027     }
6028   }
6029
6030   jresult = (void *)result;
6031   return jresult;
6032 }
6033
6034
6035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6036   void * jresult ;
6037   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6038   Dali::Vector3 *arg2 = 0 ;
6039   Dali::Vector3 result;
6040
6041   arg1 = (Dali::Vector3 *)jarg1;
6042   arg2 = (Dali::Vector3 *)jarg2;
6043   if (!arg2) {
6044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6045     return 0;
6046   }
6047   {
6048     try {
6049       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6050     } catch (std::out_of_range& e) {
6051       {
6052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6053       };
6054     } catch (std::exception& e) {
6055       {
6056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6057       };
6058     } catch (Dali::DaliException e) {
6059       {
6060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6061       };
6062     } catch (...) {
6063       {
6064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6065       };
6066     }
6067   }
6068
6069   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6070   return jresult;
6071 }
6072
6073
6074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6075   void * jresult ;
6076   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6077   Dali::Vector3 *arg2 = 0 ;
6078   Dali::Vector3 *result = 0 ;
6079
6080   arg1 = (Dali::Vector3 *)jarg1;
6081   arg2 = (Dali::Vector3 *)jarg2;
6082   if (!arg2) {
6083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6084     return 0;
6085   }
6086   {
6087     try {
6088       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6089     } catch (std::out_of_range& e) {
6090       {
6091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6092       };
6093     } catch (std::exception& e) {
6094       {
6095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6096       };
6097     } catch (Dali::DaliException e) {
6098       {
6099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6100       };
6101     } catch (...) {
6102       {
6103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6104       };
6105     }
6106   }
6107
6108   jresult = (void *)result;
6109   return jresult;
6110 }
6111
6112
6113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6114   void * jresult ;
6115   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6116   Dali::Vector3 *arg2 = 0 ;
6117   Dali::Vector3 result;
6118
6119   arg1 = (Dali::Vector3 *)jarg1;
6120   arg2 = (Dali::Vector3 *)jarg2;
6121   if (!arg2) {
6122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6123     return 0;
6124   }
6125   {
6126     try {
6127       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6128     } catch (std::out_of_range& e) {
6129       {
6130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6131       };
6132     } catch (std::exception& e) {
6133       {
6134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6135       };
6136     } catch (Dali::DaliException e) {
6137       {
6138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6139       };
6140     } catch (...) {
6141       {
6142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6143       };
6144     }
6145   }
6146
6147   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6148   return jresult;
6149 }
6150
6151
6152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6153   void * jresult ;
6154   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6155   float arg2 ;
6156   Dali::Vector3 result;
6157
6158   arg1 = (Dali::Vector3 *)jarg1;
6159   arg2 = (float)jarg2;
6160   {
6161     try {
6162       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6163     } catch (std::out_of_range& e) {
6164       {
6165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6166       };
6167     } catch (std::exception& e) {
6168       {
6169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6170       };
6171     } catch (Dali::DaliException e) {
6172       {
6173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6174       };
6175     } catch (...) {
6176       {
6177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6178       };
6179     }
6180   }
6181
6182   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6183   return jresult;
6184 }
6185
6186
6187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6188   void * jresult ;
6189   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6190   Dali::Vector3 *arg2 = 0 ;
6191   Dali::Vector3 *result = 0 ;
6192
6193   arg1 = (Dali::Vector3 *)jarg1;
6194   arg2 = (Dali::Vector3 *)jarg2;
6195   if (!arg2) {
6196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6197     return 0;
6198   }
6199   {
6200     try {
6201       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6202     } catch (std::out_of_range& e) {
6203       {
6204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6205       };
6206     } catch (std::exception& e) {
6207       {
6208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6209       };
6210     } catch (Dali::DaliException e) {
6211       {
6212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6213       };
6214     } catch (...) {
6215       {
6216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6217       };
6218     }
6219   }
6220
6221   jresult = (void *)result;
6222   return jresult;
6223 }
6224
6225
6226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6227   void * jresult ;
6228   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6229   float arg2 ;
6230   Dali::Vector3 *result = 0 ;
6231
6232   arg1 = (Dali::Vector3 *)jarg1;
6233   arg2 = (float)jarg2;
6234   {
6235     try {
6236       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6237     } catch (std::out_of_range& e) {
6238       {
6239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6240       };
6241     } catch (std::exception& e) {
6242       {
6243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6244       };
6245     } catch (Dali::DaliException e) {
6246       {
6247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6248       };
6249     } catch (...) {
6250       {
6251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6252       };
6253     }
6254   }
6255
6256   jresult = (void *)result;
6257   return jresult;
6258 }
6259
6260
6261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6262   void * jresult ;
6263   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6264   Dali::Quaternion *arg2 = 0 ;
6265   Dali::Vector3 *result = 0 ;
6266
6267   arg1 = (Dali::Vector3 *)jarg1;
6268   arg2 = (Dali::Quaternion *)jarg2;
6269   if (!arg2) {
6270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6271     return 0;
6272   }
6273   {
6274     try {
6275       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6276     } catch (std::out_of_range& e) {
6277       {
6278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6279       };
6280     } catch (std::exception& e) {
6281       {
6282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6283       };
6284     } catch (Dali::DaliException e) {
6285       {
6286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6287       };
6288     } catch (...) {
6289       {
6290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6291       };
6292     }
6293   }
6294
6295   jresult = (void *)result;
6296   return jresult;
6297 }
6298
6299
6300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6301   void * jresult ;
6302   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6303   Dali::Vector3 *arg2 = 0 ;
6304   Dali::Vector3 result;
6305
6306   arg1 = (Dali::Vector3 *)jarg1;
6307   arg2 = (Dali::Vector3 *)jarg2;
6308   if (!arg2) {
6309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6310     return 0;
6311   }
6312   {
6313     try {
6314       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6315     } catch (std::out_of_range& e) {
6316       {
6317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6318       };
6319     } catch (std::exception& e) {
6320       {
6321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6322       };
6323     } catch (Dali::DaliException e) {
6324       {
6325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6326       };
6327     } catch (...) {
6328       {
6329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6330       };
6331     }
6332   }
6333
6334   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6335   return jresult;
6336 }
6337
6338
6339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6340   void * jresult ;
6341   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6342   float arg2 ;
6343   Dali::Vector3 result;
6344
6345   arg1 = (Dali::Vector3 *)jarg1;
6346   arg2 = (float)jarg2;
6347   {
6348     try {
6349       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6350     } catch (std::out_of_range& e) {
6351       {
6352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6353       };
6354     } catch (std::exception& e) {
6355       {
6356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6357       };
6358     } catch (Dali::DaliException e) {
6359       {
6360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6361       };
6362     } catch (...) {
6363       {
6364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6365       };
6366     }
6367   }
6368
6369   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6370   return jresult;
6371 }
6372
6373
6374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6375   void * jresult ;
6376   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6377   Dali::Vector3 *arg2 = 0 ;
6378   Dali::Vector3 *result = 0 ;
6379
6380   arg1 = (Dali::Vector3 *)jarg1;
6381   arg2 = (Dali::Vector3 *)jarg2;
6382   if (!arg2) {
6383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6384     return 0;
6385   }
6386   {
6387     try {
6388       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6389     } catch (std::out_of_range& e) {
6390       {
6391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6392       };
6393     } catch (std::exception& e) {
6394       {
6395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6396       };
6397     } catch (Dali::DaliException e) {
6398       {
6399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6400       };
6401     } catch (...) {
6402       {
6403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6404       };
6405     }
6406   }
6407
6408   jresult = (void *)result;
6409   return jresult;
6410 }
6411
6412
6413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6414   void * jresult ;
6415   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6416   float arg2 ;
6417   Dali::Vector3 *result = 0 ;
6418
6419   arg1 = (Dali::Vector3 *)jarg1;
6420   arg2 = (float)jarg2;
6421   {
6422     try {
6423       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6424     } catch (std::out_of_range& e) {
6425       {
6426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6427       };
6428     } catch (std::exception& e) {
6429       {
6430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6431       };
6432     } catch (Dali::DaliException e) {
6433       {
6434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6435       };
6436     } catch (...) {
6437       {
6438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6439       };
6440     }
6441   }
6442
6443   jresult = (void *)result;
6444   return jresult;
6445 }
6446
6447
6448 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6449   void * jresult ;
6450   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6451   Dali::Vector3 result;
6452
6453   arg1 = (Dali::Vector3 *)jarg1;
6454   {
6455     try {
6456       result = ((Dali::Vector3 const *)arg1)->operator -();
6457     } catch (std::out_of_range& e) {
6458       {
6459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6460       };
6461     } catch (std::exception& e) {
6462       {
6463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6464       };
6465     } catch (Dali::DaliException e) {
6466       {
6467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6468       };
6469     } catch (...) {
6470       {
6471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6472       };
6473     }
6474   }
6475
6476   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6477   return jresult;
6478 }
6479
6480
6481 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6482   unsigned int jresult ;
6483   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6484   Dali::Vector3 *arg2 = 0 ;
6485   bool result;
6486
6487   arg1 = (Dali::Vector3 *)jarg1;
6488   arg2 = (Dali::Vector3 *)jarg2;
6489   if (!arg2) {
6490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6491     return 0;
6492   }
6493   {
6494     try {
6495       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6496     } catch (std::out_of_range& e) {
6497       {
6498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6499       };
6500     } catch (std::exception& e) {
6501       {
6502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6503       };
6504     } catch (Dali::DaliException e) {
6505       {
6506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6507       };
6508     } catch (...) {
6509       {
6510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6511       };
6512     }
6513   }
6514
6515   jresult = result;
6516   return jresult;
6517 }
6518
6519
6520 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6521   unsigned int jresult ;
6522   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6523   Dali::Vector3 *arg2 = 0 ;
6524   bool result;
6525
6526   arg1 = (Dali::Vector3 *)jarg1;
6527   arg2 = (Dali::Vector3 *)jarg2;
6528   if (!arg2) {
6529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6530     return 0;
6531   }
6532   {
6533     try {
6534       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6535     } catch (std::out_of_range& e) {
6536       {
6537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6538       };
6539     } catch (std::exception& e) {
6540       {
6541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6542       };
6543     } catch (Dali::DaliException e) {
6544       {
6545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6546       };
6547     } catch (...) {
6548       {
6549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6550       };
6551     }
6552   }
6553
6554   jresult = result;
6555   return jresult;
6556 }
6557
6558
6559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6560   float jresult ;
6561   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6562   unsigned int arg2 ;
6563   float *result = 0 ;
6564
6565   arg1 = (Dali::Vector3 *)jarg1;
6566   arg2 = (unsigned int)jarg2;
6567   {
6568     try {
6569       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6570     } catch (std::out_of_range& e) {
6571       {
6572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6573       };
6574     } catch (std::exception& e) {
6575       {
6576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6577       };
6578     } catch (Dali::DaliException e) {
6579       {
6580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6581       };
6582     } catch (...) {
6583       {
6584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6585       };
6586     }
6587   }
6588
6589   jresult = *result;
6590   return jresult;
6591 }
6592
6593
6594 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6595   float jresult ;
6596   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6597   Dali::Vector3 *arg2 = 0 ;
6598   float result;
6599
6600   arg1 = (Dali::Vector3 *)jarg1;
6601   arg2 = (Dali::Vector3 *)jarg2;
6602   if (!arg2) {
6603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6604     return 0;
6605   }
6606   {
6607     try {
6608       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6609     } catch (std::out_of_range& e) {
6610       {
6611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6612       };
6613     } catch (std::exception& e) {
6614       {
6615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6616       };
6617     } catch (Dali::DaliException e) {
6618       {
6619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6620       };
6621     } catch (...) {
6622       {
6623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6624       };
6625     }
6626   }
6627
6628   jresult = result;
6629   return jresult;
6630 }
6631
6632
6633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6634   void * jresult ;
6635   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6636   Dali::Vector3 *arg2 = 0 ;
6637   Dali::Vector3 result;
6638
6639   arg1 = (Dali::Vector3 *)jarg1;
6640   arg2 = (Dali::Vector3 *)jarg2;
6641   if (!arg2) {
6642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6643     return 0;
6644   }
6645   {
6646     try {
6647       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6648     } catch (std::out_of_range& e) {
6649       {
6650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6651       };
6652     } catch (std::exception& e) {
6653       {
6654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6655       };
6656     } catch (Dali::DaliException e) {
6657       {
6658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6659       };
6660     } catch (...) {
6661       {
6662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6663       };
6664     }
6665   }
6666
6667   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6668   return jresult;
6669 }
6670
6671
6672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6673   float jresult ;
6674   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6675   float result;
6676
6677   arg1 = (Dali::Vector3 *)jarg1;
6678   {
6679     try {
6680       result = (float)((Dali::Vector3 const *)arg1)->Length();
6681     } catch (std::out_of_range& e) {
6682       {
6683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6684       };
6685     } catch (std::exception& e) {
6686       {
6687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6688       };
6689     } catch (Dali::DaliException e) {
6690       {
6691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6692       };
6693     } catch (...) {
6694       {
6695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6696       };
6697     }
6698   }
6699
6700   jresult = result;
6701   return jresult;
6702 }
6703
6704
6705 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6706   float jresult ;
6707   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6708   float result;
6709
6710   arg1 = (Dali::Vector3 *)jarg1;
6711   {
6712     try {
6713       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6714     } catch (std::out_of_range& e) {
6715       {
6716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6717       };
6718     } catch (std::exception& e) {
6719       {
6720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6721       };
6722     } catch (Dali::DaliException e) {
6723       {
6724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6725       };
6726     } catch (...) {
6727       {
6728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6729       };
6730     }
6731   }
6732
6733   jresult = result;
6734   return jresult;
6735 }
6736
6737
6738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6739   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6740
6741   arg1 = (Dali::Vector3 *)jarg1;
6742   {
6743     try {
6744       (arg1)->Normalize();
6745     } catch (std::out_of_range& e) {
6746       {
6747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6748       };
6749     } catch (std::exception& e) {
6750       {
6751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6752       };
6753     } catch (Dali::DaliException e) {
6754       {
6755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6756       };
6757     } catch (...) {
6758       {
6759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6760       };
6761     }
6762   }
6763
6764 }
6765
6766
6767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6768   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6769   Dali::Vector3 *arg2 = 0 ;
6770   Dali::Vector3 *arg3 = 0 ;
6771
6772   arg1 = (Dali::Vector3 *)jarg1;
6773   arg2 = (Dali::Vector3 *)jarg2;
6774   if (!arg2) {
6775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6776     return ;
6777   }
6778   arg3 = (Dali::Vector3 *)jarg3;
6779   if (!arg3) {
6780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6781     return ;
6782   }
6783   {
6784     try {
6785       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6786     } catch (std::out_of_range& e) {
6787       {
6788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6789       };
6790     } catch (std::exception& e) {
6791       {
6792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6793       };
6794     } catch (Dali::DaliException e) {
6795       {
6796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6797       };
6798     } catch (...) {
6799       {
6800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6801       };
6802     }
6803   }
6804
6805 }
6806
6807
6808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6809   void * jresult ;
6810   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6811   float *result = 0 ;
6812
6813   arg1 = (Dali::Vector3 *)jarg1;
6814   {
6815     try {
6816       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6817     } catch (std::out_of_range& e) {
6818       {
6819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6820       };
6821     } catch (std::exception& e) {
6822       {
6823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6824       };
6825     } catch (Dali::DaliException e) {
6826       {
6827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6828       };
6829     } catch (...) {
6830       {
6831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6832       };
6833     }
6834   }
6835
6836   jresult = (void *)result;
6837   return jresult;
6838 }
6839
6840
6841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6842   void * jresult ;
6843   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6844   Dali::Vector2 *result = 0 ;
6845
6846   arg1 = (Dali::Vector3 *)jarg1;
6847   {
6848     try {
6849       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6850     } catch (std::out_of_range& e) {
6851       {
6852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6853       };
6854     } catch (std::exception& e) {
6855       {
6856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6857       };
6858     } catch (Dali::DaliException e) {
6859       {
6860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6861       };
6862     } catch (...) {
6863       {
6864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6865       };
6866     }
6867   }
6868
6869   jresult = (void *)result;
6870   return jresult;
6871 }
6872
6873
6874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6875   void * jresult ;
6876   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6877   Dali::Vector2 *result = 0 ;
6878
6879   arg1 = (Dali::Vector3 *)jarg1;
6880   {
6881     try {
6882       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6883     } catch (std::out_of_range& e) {
6884       {
6885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6886       };
6887     } catch (std::exception& e) {
6888       {
6889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6890       };
6891     } catch (Dali::DaliException e) {
6892       {
6893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6894       };
6895     } catch (...) {
6896       {
6897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6898       };
6899     }
6900   }
6901
6902   jresult = (void *)result;
6903   return jresult;
6904 }
6905
6906
6907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6908   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6909   float arg2 ;
6910
6911   arg1 = (Dali::Vector3 *)jarg1;
6912   arg2 = (float)jarg2;
6913   if (arg1) (arg1)->x = arg2;
6914 }
6915
6916
6917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6918   float jresult ;
6919   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6920   float result;
6921
6922   arg1 = (Dali::Vector3 *)jarg1;
6923   result = (float) ((arg1)->x);
6924   jresult = result;
6925   return jresult;
6926 }
6927
6928
6929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6930   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6931   float arg2 ;
6932
6933   arg1 = (Dali::Vector3 *)jarg1;
6934   arg2 = (float)jarg2;
6935   if (arg1) (arg1)->width = arg2;
6936 }
6937
6938
6939 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6940   float jresult ;
6941   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6942   float result;
6943
6944   arg1 = (Dali::Vector3 *)jarg1;
6945   result = (float) ((arg1)->width);
6946   jresult = result;
6947   return jresult;
6948 }
6949
6950
6951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6952   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6953   float arg2 ;
6954
6955   arg1 = (Dali::Vector3 *)jarg1;
6956   arg2 = (float)jarg2;
6957   if (arg1) (arg1)->r = arg2;
6958 }
6959
6960
6961 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6962   float jresult ;
6963   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6964   float result;
6965
6966   arg1 = (Dali::Vector3 *)jarg1;
6967   result = (float) ((arg1)->r);
6968   jresult = result;
6969   return jresult;
6970 }
6971
6972
6973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6974   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6975   float arg2 ;
6976
6977   arg1 = (Dali::Vector3 *)jarg1;
6978   arg2 = (float)jarg2;
6979   if (arg1) (arg1)->y = arg2;
6980 }
6981
6982
6983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6984   float jresult ;
6985   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6986   float result;
6987
6988   arg1 = (Dali::Vector3 *)jarg1;
6989   result = (float) ((arg1)->y);
6990   jresult = result;
6991   return jresult;
6992 }
6993
6994
6995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6996   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6997   float arg2 ;
6998
6999   arg1 = (Dali::Vector3 *)jarg1;
7000   arg2 = (float)jarg2;
7001   if (arg1) (arg1)->height = arg2;
7002 }
7003
7004
7005 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7006   float jresult ;
7007   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7008   float result;
7009
7010   arg1 = (Dali::Vector3 *)jarg1;
7011   result = (float) ((arg1)->height);
7012   jresult = result;
7013   return jresult;
7014 }
7015
7016
7017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7018   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7019   float arg2 ;
7020
7021   arg1 = (Dali::Vector3 *)jarg1;
7022   arg2 = (float)jarg2;
7023   if (arg1) (arg1)->g = arg2;
7024 }
7025
7026
7027 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7028   float jresult ;
7029   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7030   float result;
7031
7032   arg1 = (Dali::Vector3 *)jarg1;
7033   result = (float) ((arg1)->g);
7034   jresult = result;
7035   return jresult;
7036 }
7037
7038
7039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7040   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7041   float arg2 ;
7042
7043   arg1 = (Dali::Vector3 *)jarg1;
7044   arg2 = (float)jarg2;
7045   if (arg1) (arg1)->z = arg2;
7046 }
7047
7048
7049 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7050   float jresult ;
7051   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7052   float result;
7053
7054   arg1 = (Dali::Vector3 *)jarg1;
7055   result = (float) ((arg1)->z);
7056   jresult = result;
7057   return jresult;
7058 }
7059
7060
7061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7062   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7063   float arg2 ;
7064
7065   arg1 = (Dali::Vector3 *)jarg1;
7066   arg2 = (float)jarg2;
7067   if (arg1) (arg1)->depth = arg2;
7068 }
7069
7070
7071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7072   float jresult ;
7073   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7074   float result;
7075
7076   arg1 = (Dali::Vector3 *)jarg1;
7077   result = (float) ((arg1)->depth);
7078   jresult = result;
7079   return jresult;
7080 }
7081
7082
7083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7084   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7085   float arg2 ;
7086
7087   arg1 = (Dali::Vector3 *)jarg1;
7088   arg2 = (float)jarg2;
7089   if (arg1) (arg1)->b = arg2;
7090 }
7091
7092
7093 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7094   float jresult ;
7095   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7096   float result;
7097
7098   arg1 = (Dali::Vector3 *)jarg1;
7099   result = (float) ((arg1)->b);
7100   jresult = result;
7101   return jresult;
7102 }
7103
7104
7105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7106   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7107
7108   arg1 = (Dali::Vector3 *)jarg1;
7109   {
7110     try {
7111       delete arg1;
7112     } catch (std::out_of_range& e) {
7113       {
7114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7115       };
7116     } catch (std::exception& e) {
7117       {
7118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7119       };
7120     } catch (Dali::DaliException e) {
7121       {
7122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7123       };
7124     } catch (...) {
7125       {
7126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7127       };
7128     }
7129   }
7130
7131 }
7132
7133
7134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7135   void * jresult ;
7136   Dali::Vector3 *arg1 = 0 ;
7137   Dali::Vector3 *arg2 = 0 ;
7138   Dali::Vector3 result;
7139
7140   arg1 = (Dali::Vector3 *)jarg1;
7141   if (!arg1) {
7142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7143     return 0;
7144   }
7145   arg2 = (Dali::Vector3 *)jarg2;
7146   if (!arg2) {
7147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7148     return 0;
7149   }
7150   {
7151     try {
7152       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7153     } catch (std::out_of_range& e) {
7154       {
7155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7156       };
7157     } catch (std::exception& e) {
7158       {
7159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7160       };
7161     } catch (Dali::DaliException e) {
7162       {
7163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7164       };
7165     } catch (...) {
7166       {
7167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7168       };
7169     }
7170   }
7171
7172   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7173   return jresult;
7174 }
7175
7176
7177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7178   void * jresult ;
7179   Dali::Vector3 *arg1 = 0 ;
7180   Dali::Vector3 *arg2 = 0 ;
7181   Dali::Vector3 result;
7182
7183   arg1 = (Dali::Vector3 *)jarg1;
7184   if (!arg1) {
7185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7186     return 0;
7187   }
7188   arg2 = (Dali::Vector3 *)jarg2;
7189   if (!arg2) {
7190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7191     return 0;
7192   }
7193   {
7194     try {
7195       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7196     } catch (std::out_of_range& e) {
7197       {
7198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7199       };
7200     } catch (std::exception& e) {
7201       {
7202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7203       };
7204     } catch (Dali::DaliException e) {
7205       {
7206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7207       };
7208     } catch (...) {
7209       {
7210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7211       };
7212     }
7213   }
7214
7215   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7216   return jresult;
7217 }
7218
7219
7220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7221   void * jresult ;
7222   Dali::Vector3 *arg1 = 0 ;
7223   float *arg2 = 0 ;
7224   float *arg3 = 0 ;
7225   float temp2 ;
7226   float temp3 ;
7227   Dali::Vector3 result;
7228
7229   arg1 = (Dali::Vector3 *)jarg1;
7230   if (!arg1) {
7231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7232     return 0;
7233   }
7234   temp2 = (float)jarg2;
7235   arg2 = &temp2;
7236   temp3 = (float)jarg3;
7237   arg3 = &temp3;
7238   {
7239     try {
7240       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7241     } catch (std::out_of_range& e) {
7242       {
7243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7244       };
7245     } catch (std::exception& e) {
7246       {
7247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7248       };
7249     } catch (Dali::DaliException e) {
7250       {
7251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7252       };
7253     } catch (...) {
7254       {
7255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7256       };
7257     }
7258   }
7259
7260   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7261   return jresult;
7262 }
7263
7264
7265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7266   void * jresult ;
7267   Dali::Vector4 *result = 0 ;
7268
7269   {
7270     try {
7271       result = (Dali::Vector4 *)new Dali::Vector4();
7272     } catch (std::out_of_range& e) {
7273       {
7274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7275       };
7276     } catch (std::exception& e) {
7277       {
7278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7279       };
7280     } catch (Dali::DaliException e) {
7281       {
7282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7283       };
7284     } catch (...) {
7285       {
7286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7287       };
7288     }
7289   }
7290
7291   jresult = (void *)result;
7292   return jresult;
7293 }
7294
7295
7296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7297   void * jresult ;
7298   float arg1 ;
7299   float arg2 ;
7300   float arg3 ;
7301   float arg4 ;
7302   Dali::Vector4 *result = 0 ;
7303
7304   arg1 = (float)jarg1;
7305   arg2 = (float)jarg2;
7306   arg3 = (float)jarg3;
7307   arg4 = (float)jarg4;
7308   {
7309     try {
7310       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7311     } catch (std::out_of_range& e) {
7312       {
7313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7314       };
7315     } catch (std::exception& e) {
7316       {
7317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7318       };
7319     } catch (Dali::DaliException e) {
7320       {
7321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7322       };
7323     } catch (...) {
7324       {
7325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7326       };
7327     }
7328   }
7329
7330   jresult = (void *)result;
7331   return jresult;
7332 }
7333
7334
7335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7336   void * jresult ;
7337   float *arg1 = (float *) 0 ;
7338   Dali::Vector4 *result = 0 ;
7339
7340   arg1 = jarg1;
7341   {
7342     try {
7343       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7344     } catch (std::out_of_range& e) {
7345       {
7346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7347       };
7348     } catch (std::exception& e) {
7349       {
7350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7351       };
7352     } catch (Dali::DaliException e) {
7353       {
7354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7355       };
7356     } catch (...) {
7357       {
7358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7359       };
7360     }
7361   }
7362
7363   jresult = (void *)result;
7364
7365
7366   return jresult;
7367 }
7368
7369
7370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7371   void * jresult ;
7372   Dali::Vector2 *arg1 = 0 ;
7373   Dali::Vector4 *result = 0 ;
7374
7375   arg1 = (Dali::Vector2 *)jarg1;
7376   if (!arg1) {
7377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7378     return 0;
7379   }
7380   {
7381     try {
7382       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7383     } catch (std::out_of_range& e) {
7384       {
7385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7386       };
7387     } catch (std::exception& e) {
7388       {
7389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7390       };
7391     } catch (Dali::DaliException e) {
7392       {
7393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7394       };
7395     } catch (...) {
7396       {
7397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7398       };
7399     }
7400   }
7401
7402   jresult = (void *)result;
7403   return jresult;
7404 }
7405
7406
7407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7408   void * jresult ;
7409   Dali::Vector3 *arg1 = 0 ;
7410   Dali::Vector4 *result = 0 ;
7411
7412   arg1 = (Dali::Vector3 *)jarg1;
7413   if (!arg1) {
7414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7415     return 0;
7416   }
7417   {
7418     try {
7419       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7420     } catch (std::out_of_range& e) {
7421       {
7422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7423       };
7424     } catch (std::exception& e) {
7425       {
7426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7427       };
7428     } catch (Dali::DaliException e) {
7429       {
7430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7431       };
7432     } catch (...) {
7433       {
7434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7435       };
7436     }
7437   }
7438
7439   jresult = (void *)result;
7440   return jresult;
7441 }
7442
7443
7444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7445   void * jresult ;
7446   Dali::Vector4 *result = 0 ;
7447
7448   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7449   jresult = (void *)result;
7450   return jresult;
7451 }
7452
7453
7454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7455   void * jresult ;
7456   Dali::Vector4 *result = 0 ;
7457
7458   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7459   jresult = (void *)result;
7460   return jresult;
7461 }
7462
7463
7464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7465   void * jresult ;
7466   Dali::Vector4 *result = 0 ;
7467
7468   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7469   jresult = (void *)result;
7470   return jresult;
7471 }
7472
7473
7474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7475   void * jresult ;
7476   Dali::Vector4 *result = 0 ;
7477
7478   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7479   jresult = (void *)result;
7480   return jresult;
7481 }
7482
7483
7484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7485   void * jresult ;
7486   Dali::Vector4 *result = 0 ;
7487
7488   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7489   jresult = (void *)result;
7490   return jresult;
7491 }
7492
7493
7494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7495   void * jresult ;
7496   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7497   float *arg2 = (float *) 0 ;
7498   Dali::Vector4 *result = 0 ;
7499
7500   arg1 = (Dali::Vector4 *)jarg1;
7501   arg2 = jarg2;
7502   {
7503     try {
7504       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7505     } catch (std::out_of_range& e) {
7506       {
7507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7508       };
7509     } catch (std::exception& e) {
7510       {
7511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7512       };
7513     } catch (Dali::DaliException e) {
7514       {
7515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7516       };
7517     } catch (...) {
7518       {
7519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7520       };
7521     }
7522   }
7523
7524   jresult = (void *)result;
7525
7526
7527   return jresult;
7528 }
7529
7530
7531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7532   void * jresult ;
7533   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7534   Dali::Vector2 *arg2 = 0 ;
7535   Dali::Vector4 *result = 0 ;
7536
7537   arg1 = (Dali::Vector4 *)jarg1;
7538   arg2 = (Dali::Vector2 *)jarg2;
7539   if (!arg2) {
7540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7541     return 0;
7542   }
7543   {
7544     try {
7545       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7546     } catch (std::out_of_range& e) {
7547       {
7548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7549       };
7550     } catch (std::exception& e) {
7551       {
7552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7553       };
7554     } catch (Dali::DaliException e) {
7555       {
7556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7557       };
7558     } catch (...) {
7559       {
7560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7561       };
7562     }
7563   }
7564
7565   jresult = (void *)result;
7566   return jresult;
7567 }
7568
7569
7570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7571   void * jresult ;
7572   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7573   Dali::Vector3 *arg2 = 0 ;
7574   Dali::Vector4 *result = 0 ;
7575
7576   arg1 = (Dali::Vector4 *)jarg1;
7577   arg2 = (Dali::Vector3 *)jarg2;
7578   if (!arg2) {
7579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7580     return 0;
7581   }
7582   {
7583     try {
7584       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7585     } catch (std::out_of_range& e) {
7586       {
7587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7588       };
7589     } catch (std::exception& e) {
7590       {
7591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7592       };
7593     } catch (Dali::DaliException e) {
7594       {
7595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7596       };
7597     } catch (...) {
7598       {
7599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7600       };
7601     }
7602   }
7603
7604   jresult = (void *)result;
7605   return jresult;
7606 }
7607
7608
7609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7610   void * jresult ;
7611   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7612   Dali::Vector4 *arg2 = 0 ;
7613   Dali::Vector4 result;
7614
7615   arg1 = (Dali::Vector4 *)jarg1;
7616   arg2 = (Dali::Vector4 *)jarg2;
7617   if (!arg2) {
7618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7619     return 0;
7620   }
7621   {
7622     try {
7623       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7624     } catch (std::out_of_range& e) {
7625       {
7626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7627       };
7628     } catch (std::exception& e) {
7629       {
7630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7631       };
7632     } catch (Dali::DaliException e) {
7633       {
7634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7635       };
7636     } catch (...) {
7637       {
7638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7639       };
7640     }
7641   }
7642
7643   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7644   return jresult;
7645 }
7646
7647
7648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7649   void * jresult ;
7650   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7651   Dali::Vector4 *arg2 = 0 ;
7652   Dali::Vector4 *result = 0 ;
7653
7654   arg1 = (Dali::Vector4 *)jarg1;
7655   arg2 = (Dali::Vector4 *)jarg2;
7656   if (!arg2) {
7657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7658     return 0;
7659   }
7660   {
7661     try {
7662       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7663     } catch (std::out_of_range& e) {
7664       {
7665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7666       };
7667     } catch (std::exception& e) {
7668       {
7669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7670       };
7671     } catch (Dali::DaliException e) {
7672       {
7673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7674       };
7675     } catch (...) {
7676       {
7677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7678       };
7679     }
7680   }
7681
7682   jresult = (void *)result;
7683   return jresult;
7684 }
7685
7686
7687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7688   void * jresult ;
7689   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7690   Dali::Vector4 *arg2 = 0 ;
7691   Dali::Vector4 result;
7692
7693   arg1 = (Dali::Vector4 *)jarg1;
7694   arg2 = (Dali::Vector4 *)jarg2;
7695   if (!arg2) {
7696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7697     return 0;
7698   }
7699   {
7700     try {
7701       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7702     } catch (std::out_of_range& e) {
7703       {
7704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7705       };
7706     } catch (std::exception& e) {
7707       {
7708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7709       };
7710     } catch (Dali::DaliException e) {
7711       {
7712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7713       };
7714     } catch (...) {
7715       {
7716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7717       };
7718     }
7719   }
7720
7721   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7722   return jresult;
7723 }
7724
7725
7726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7727   void * jresult ;
7728   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7729   Dali::Vector4 *arg2 = 0 ;
7730   Dali::Vector4 *result = 0 ;
7731
7732   arg1 = (Dali::Vector4 *)jarg1;
7733   arg2 = (Dali::Vector4 *)jarg2;
7734   if (!arg2) {
7735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7736     return 0;
7737   }
7738   {
7739     try {
7740       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7741     } catch (std::out_of_range& e) {
7742       {
7743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7744       };
7745     } catch (std::exception& e) {
7746       {
7747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7748       };
7749     } catch (Dali::DaliException e) {
7750       {
7751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7752       };
7753     } catch (...) {
7754       {
7755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7756       };
7757     }
7758   }
7759
7760   jresult = (void *)result;
7761   return jresult;
7762 }
7763
7764
7765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7766   void * jresult ;
7767   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7768   Dali::Vector4 *arg2 = 0 ;
7769   Dali::Vector4 result;
7770
7771   arg1 = (Dali::Vector4 *)jarg1;
7772   arg2 = (Dali::Vector4 *)jarg2;
7773   if (!arg2) {
7774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7775     return 0;
7776   }
7777   {
7778     try {
7779       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7780     } catch (std::out_of_range& e) {
7781       {
7782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7783       };
7784     } catch (std::exception& e) {
7785       {
7786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7787       };
7788     } catch (Dali::DaliException e) {
7789       {
7790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7791       };
7792     } catch (...) {
7793       {
7794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7795       };
7796     }
7797   }
7798
7799   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7800   return jresult;
7801 }
7802
7803
7804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7805   void * jresult ;
7806   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7807   float arg2 ;
7808   Dali::Vector4 result;
7809
7810   arg1 = (Dali::Vector4 *)jarg1;
7811   arg2 = (float)jarg2;
7812   {
7813     try {
7814       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7815     } catch (std::out_of_range& e) {
7816       {
7817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7818       };
7819     } catch (std::exception& e) {
7820       {
7821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7822       };
7823     } catch (Dali::DaliException e) {
7824       {
7825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7826       };
7827     } catch (...) {
7828       {
7829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7830       };
7831     }
7832   }
7833
7834   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7835   return jresult;
7836 }
7837
7838
7839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7840   void * jresult ;
7841   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7842   Dali::Vector4 *arg2 = 0 ;
7843   Dali::Vector4 *result = 0 ;
7844
7845   arg1 = (Dali::Vector4 *)jarg1;
7846   arg2 = (Dali::Vector4 *)jarg2;
7847   if (!arg2) {
7848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7849     return 0;
7850   }
7851   {
7852     try {
7853       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7854     } catch (std::out_of_range& e) {
7855       {
7856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7857       };
7858     } catch (std::exception& e) {
7859       {
7860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7861       };
7862     } catch (Dali::DaliException e) {
7863       {
7864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7865       };
7866     } catch (...) {
7867       {
7868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7869       };
7870     }
7871   }
7872
7873   jresult = (void *)result;
7874   return jresult;
7875 }
7876
7877
7878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7879   void * jresult ;
7880   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7881   float arg2 ;
7882   Dali::Vector4 *result = 0 ;
7883
7884   arg1 = (Dali::Vector4 *)jarg1;
7885   arg2 = (float)jarg2;
7886   {
7887     try {
7888       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7889     } catch (std::out_of_range& e) {
7890       {
7891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7892       };
7893     } catch (std::exception& e) {
7894       {
7895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7896       };
7897     } catch (Dali::DaliException e) {
7898       {
7899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7900       };
7901     } catch (...) {
7902       {
7903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7904       };
7905     }
7906   }
7907
7908   jresult = (void *)result;
7909   return jresult;
7910 }
7911
7912
7913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7914   void * jresult ;
7915   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7916   Dali::Vector4 *arg2 = 0 ;
7917   Dali::Vector4 result;
7918
7919   arg1 = (Dali::Vector4 *)jarg1;
7920   arg2 = (Dali::Vector4 *)jarg2;
7921   if (!arg2) {
7922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7923     return 0;
7924   }
7925   {
7926     try {
7927       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7928     } catch (std::out_of_range& e) {
7929       {
7930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7931       };
7932     } catch (std::exception& e) {
7933       {
7934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7935       };
7936     } catch (Dali::DaliException e) {
7937       {
7938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7939       };
7940     } catch (...) {
7941       {
7942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7943       };
7944     }
7945   }
7946
7947   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7948   return jresult;
7949 }
7950
7951
7952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7953   void * jresult ;
7954   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7955   float arg2 ;
7956   Dali::Vector4 result;
7957
7958   arg1 = (Dali::Vector4 *)jarg1;
7959   arg2 = (float)jarg2;
7960   {
7961     try {
7962       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7963     } catch (std::out_of_range& e) {
7964       {
7965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7966       };
7967     } catch (std::exception& e) {
7968       {
7969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7970       };
7971     } catch (Dali::DaliException e) {
7972       {
7973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7974       };
7975     } catch (...) {
7976       {
7977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7978       };
7979     }
7980   }
7981
7982   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7983   return jresult;
7984 }
7985
7986
7987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7988   void * jresult ;
7989   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7990   Dali::Vector4 *arg2 = 0 ;
7991   Dali::Vector4 *result = 0 ;
7992
7993   arg1 = (Dali::Vector4 *)jarg1;
7994   arg2 = (Dali::Vector4 *)jarg2;
7995   if (!arg2) {
7996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7997     return 0;
7998   }
7999   {
8000     try {
8001       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8002     } catch (std::out_of_range& e) {
8003       {
8004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8005       };
8006     } catch (std::exception& e) {
8007       {
8008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8009       };
8010     } catch (Dali::DaliException e) {
8011       {
8012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8013       };
8014     } catch (...) {
8015       {
8016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8017       };
8018     }
8019   }
8020
8021   jresult = (void *)result;
8022   return jresult;
8023 }
8024
8025
8026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8027   void * jresult ;
8028   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8029   float arg2 ;
8030   Dali::Vector4 *result = 0 ;
8031
8032   arg1 = (Dali::Vector4 *)jarg1;
8033   arg2 = (float)jarg2;
8034   {
8035     try {
8036       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8037     } catch (std::out_of_range& e) {
8038       {
8039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8040       };
8041     } catch (std::exception& e) {
8042       {
8043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8044       };
8045     } catch (Dali::DaliException e) {
8046       {
8047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8048       };
8049     } catch (...) {
8050       {
8051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8052       };
8053     }
8054   }
8055
8056   jresult = (void *)result;
8057   return jresult;
8058 }
8059
8060
8061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8062   void * jresult ;
8063   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8064   Dali::Vector4 result;
8065
8066   arg1 = (Dali::Vector4 *)jarg1;
8067   {
8068     try {
8069       result = ((Dali::Vector4 const *)arg1)->operator -();
8070     } catch (std::out_of_range& e) {
8071       {
8072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8073       };
8074     } catch (std::exception& e) {
8075       {
8076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8077       };
8078     } catch (Dali::DaliException e) {
8079       {
8080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8081       };
8082     } catch (...) {
8083       {
8084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8085       };
8086     }
8087   }
8088
8089   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8090   return jresult;
8091 }
8092
8093
8094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8095   unsigned int jresult ;
8096   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8097   Dali::Vector4 *arg2 = 0 ;
8098   bool result;
8099
8100   arg1 = (Dali::Vector4 *)jarg1;
8101   arg2 = (Dali::Vector4 *)jarg2;
8102   if (!arg2) {
8103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8104     return 0;
8105   }
8106   {
8107     try {
8108       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8109     } catch (std::out_of_range& e) {
8110       {
8111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8112       };
8113     } catch (std::exception& e) {
8114       {
8115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8116       };
8117     } catch (Dali::DaliException e) {
8118       {
8119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8120       };
8121     } catch (...) {
8122       {
8123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8124       };
8125     }
8126   }
8127
8128   jresult = result;
8129   return jresult;
8130 }
8131
8132
8133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8134   unsigned int jresult ;
8135   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8136   Dali::Vector4 *arg2 = 0 ;
8137   bool result;
8138
8139   arg1 = (Dali::Vector4 *)jarg1;
8140   arg2 = (Dali::Vector4 *)jarg2;
8141   if (!arg2) {
8142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8143     return 0;
8144   }
8145   {
8146     try {
8147       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8148     } catch (std::out_of_range& e) {
8149       {
8150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8151       };
8152     } catch (std::exception& e) {
8153       {
8154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8155       };
8156     } catch (Dali::DaliException e) {
8157       {
8158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8159       };
8160     } catch (...) {
8161       {
8162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8163       };
8164     }
8165   }
8166
8167   jresult = result;
8168   return jresult;
8169 }
8170
8171
8172 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8173   float jresult ;
8174   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8175   unsigned int arg2 ;
8176   float *result = 0 ;
8177
8178   arg1 = (Dali::Vector4 *)jarg1;
8179   arg2 = (unsigned int)jarg2;
8180   {
8181     try {
8182       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8183     } catch (std::out_of_range& e) {
8184       {
8185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8186       };
8187     } catch (std::exception& e) {
8188       {
8189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8190       };
8191     } catch (Dali::DaliException e) {
8192       {
8193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8194       };
8195     } catch (...) {
8196       {
8197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8198       };
8199     }
8200   }
8201
8202   jresult = *result;
8203   return jresult;
8204 }
8205
8206
8207 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8208   float jresult ;
8209   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8210   Dali::Vector3 *arg2 = 0 ;
8211   float result;
8212
8213   arg1 = (Dali::Vector4 *)jarg1;
8214   arg2 = (Dali::Vector3 *)jarg2;
8215   if (!arg2) {
8216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8217     return 0;
8218   }
8219   {
8220     try {
8221       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8222     } catch (std::out_of_range& e) {
8223       {
8224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8225       };
8226     } catch (std::exception& e) {
8227       {
8228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8229       };
8230     } catch (Dali::DaliException e) {
8231       {
8232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8233       };
8234     } catch (...) {
8235       {
8236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8237       };
8238     }
8239   }
8240
8241   jresult = result;
8242   return jresult;
8243 }
8244
8245
8246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8247   float jresult ;
8248   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8249   Dali::Vector4 *arg2 = 0 ;
8250   float result;
8251
8252   arg1 = (Dali::Vector4 *)jarg1;
8253   arg2 = (Dali::Vector4 *)jarg2;
8254   if (!arg2) {
8255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8256     return 0;
8257   }
8258   {
8259     try {
8260       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8261     } catch (std::out_of_range& e) {
8262       {
8263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8264       };
8265     } catch (std::exception& e) {
8266       {
8267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8268       };
8269     } catch (Dali::DaliException e) {
8270       {
8271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8272       };
8273     } catch (...) {
8274       {
8275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8276       };
8277     }
8278   }
8279
8280   jresult = result;
8281   return jresult;
8282 }
8283
8284
8285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8286   float jresult ;
8287   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8288   Dali::Vector4 *arg2 = 0 ;
8289   float result;
8290
8291   arg1 = (Dali::Vector4 *)jarg1;
8292   arg2 = (Dali::Vector4 *)jarg2;
8293   if (!arg2) {
8294     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8295     return 0;
8296   }
8297   {
8298     try {
8299       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8300     } catch (std::out_of_range& e) {
8301       {
8302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8303       };
8304     } catch (std::exception& e) {
8305       {
8306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8307       };
8308     } catch (Dali::DaliException e) {
8309       {
8310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8311       };
8312     } catch (...) {
8313       {
8314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8315       };
8316     }
8317   }
8318
8319   jresult = result;
8320   return jresult;
8321 }
8322
8323
8324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8325   void * jresult ;
8326   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8327   Dali::Vector4 *arg2 = 0 ;
8328   Dali::Vector4 result;
8329
8330   arg1 = (Dali::Vector4 *)jarg1;
8331   arg2 = (Dali::Vector4 *)jarg2;
8332   if (!arg2) {
8333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8334     return 0;
8335   }
8336   {
8337     try {
8338       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8339     } catch (std::out_of_range& e) {
8340       {
8341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8342       };
8343     } catch (std::exception& e) {
8344       {
8345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8346       };
8347     } catch (Dali::DaliException e) {
8348       {
8349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8350       };
8351     } catch (...) {
8352       {
8353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8354       };
8355     }
8356   }
8357
8358   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8359   return jresult;
8360 }
8361
8362
8363 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8364   float jresult ;
8365   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8366   float result;
8367
8368   arg1 = (Dali::Vector4 *)jarg1;
8369   {
8370     try {
8371       result = (float)((Dali::Vector4 const *)arg1)->Length();
8372     } catch (std::out_of_range& e) {
8373       {
8374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8375       };
8376     } catch (std::exception& e) {
8377       {
8378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8379       };
8380     } catch (Dali::DaliException e) {
8381       {
8382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8383       };
8384     } catch (...) {
8385       {
8386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8387       };
8388     }
8389   }
8390
8391   jresult = result;
8392   return jresult;
8393 }
8394
8395
8396 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8397   float jresult ;
8398   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8399   float result;
8400
8401   arg1 = (Dali::Vector4 *)jarg1;
8402   {
8403     try {
8404       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8405     } catch (std::out_of_range& e) {
8406       {
8407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8408       };
8409     } catch (std::exception& e) {
8410       {
8411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8412       };
8413     } catch (Dali::DaliException e) {
8414       {
8415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8416       };
8417     } catch (...) {
8418       {
8419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8420       };
8421     }
8422   }
8423
8424   jresult = result;
8425   return jresult;
8426 }
8427
8428
8429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8430   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8431
8432   arg1 = (Dali::Vector4 *)jarg1;
8433   {
8434     try {
8435       (arg1)->Normalize();
8436     } catch (std::out_of_range& e) {
8437       {
8438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8439       };
8440     } catch (std::exception& e) {
8441       {
8442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8443       };
8444     } catch (Dali::DaliException e) {
8445       {
8446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8447       };
8448     } catch (...) {
8449       {
8450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8451       };
8452     }
8453   }
8454
8455 }
8456
8457
8458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8459   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8460   Dali::Vector4 *arg2 = 0 ;
8461   Dali::Vector4 *arg3 = 0 ;
8462
8463   arg1 = (Dali::Vector4 *)jarg1;
8464   arg2 = (Dali::Vector4 *)jarg2;
8465   if (!arg2) {
8466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8467     return ;
8468   }
8469   arg3 = (Dali::Vector4 *)jarg3;
8470   if (!arg3) {
8471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8472     return ;
8473   }
8474   {
8475     try {
8476       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8477     } catch (std::out_of_range& e) {
8478       {
8479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8480       };
8481     } catch (std::exception& e) {
8482       {
8483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8484       };
8485     } catch (Dali::DaliException e) {
8486       {
8487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8488       };
8489     } catch (...) {
8490       {
8491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8492       };
8493     }
8494   }
8495
8496 }
8497
8498
8499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8500   void * jresult ;
8501   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8502   float *result = 0 ;
8503
8504   arg1 = (Dali::Vector4 *)jarg1;
8505   {
8506     try {
8507       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8508     } catch (std::out_of_range& e) {
8509       {
8510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8511       };
8512     } catch (std::exception& e) {
8513       {
8514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8515       };
8516     } catch (Dali::DaliException e) {
8517       {
8518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8519       };
8520     } catch (...) {
8521       {
8522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8523       };
8524     }
8525   }
8526
8527   jresult = (void *)result;
8528   return jresult;
8529 }
8530
8531
8532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8533   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8534   float arg2 ;
8535
8536   arg1 = (Dali::Vector4 *)jarg1;
8537   arg2 = (float)jarg2;
8538   if (arg1) (arg1)->x = arg2;
8539 }
8540
8541
8542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8543   float jresult ;
8544   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8545   float result;
8546
8547   arg1 = (Dali::Vector4 *)jarg1;
8548   result = (float) ((arg1)->x);
8549   jresult = result;
8550   return jresult;
8551 }
8552
8553
8554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8555   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8556   float arg2 ;
8557
8558   arg1 = (Dali::Vector4 *)jarg1;
8559   arg2 = (float)jarg2;
8560   if (arg1) (arg1)->r = arg2;
8561 }
8562
8563
8564 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8565   float jresult ;
8566   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8567   float result;
8568
8569   arg1 = (Dali::Vector4 *)jarg1;
8570   result = (float) ((arg1)->r);
8571   jresult = result;
8572   return jresult;
8573 }
8574
8575
8576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8577   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8578   float arg2 ;
8579
8580   arg1 = (Dali::Vector4 *)jarg1;
8581   arg2 = (float)jarg2;
8582   if (arg1) (arg1)->s = arg2;
8583 }
8584
8585
8586 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8587   float jresult ;
8588   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8589   float result;
8590
8591   arg1 = (Dali::Vector4 *)jarg1;
8592   result = (float) ((arg1)->s);
8593   jresult = result;
8594   return jresult;
8595 }
8596
8597
8598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8599   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8600   float arg2 ;
8601
8602   arg1 = (Dali::Vector4 *)jarg1;
8603   arg2 = (float)jarg2;
8604   if (arg1) (arg1)->y = arg2;
8605 }
8606
8607
8608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8609   float jresult ;
8610   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8611   float result;
8612
8613   arg1 = (Dali::Vector4 *)jarg1;
8614   result = (float) ((arg1)->y);
8615   jresult = result;
8616   return jresult;
8617 }
8618
8619
8620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8621   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8622   float arg2 ;
8623
8624   arg1 = (Dali::Vector4 *)jarg1;
8625   arg2 = (float)jarg2;
8626   if (arg1) (arg1)->g = arg2;
8627 }
8628
8629
8630 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8631   float jresult ;
8632   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8633   float result;
8634
8635   arg1 = (Dali::Vector4 *)jarg1;
8636   result = (float) ((arg1)->g);
8637   jresult = result;
8638   return jresult;
8639 }
8640
8641
8642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8643   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8644   float arg2 ;
8645
8646   arg1 = (Dali::Vector4 *)jarg1;
8647   arg2 = (float)jarg2;
8648   if (arg1) (arg1)->t = arg2;
8649 }
8650
8651
8652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8653   float jresult ;
8654   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8655   float result;
8656
8657   arg1 = (Dali::Vector4 *)jarg1;
8658   result = (float) ((arg1)->t);
8659   jresult = result;
8660   return jresult;
8661 }
8662
8663
8664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8665   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8666   float arg2 ;
8667
8668   arg1 = (Dali::Vector4 *)jarg1;
8669   arg2 = (float)jarg2;
8670   if (arg1) (arg1)->z = arg2;
8671 }
8672
8673
8674 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8675   float jresult ;
8676   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8677   float result;
8678
8679   arg1 = (Dali::Vector4 *)jarg1;
8680   result = (float) ((arg1)->z);
8681   jresult = result;
8682   return jresult;
8683 }
8684
8685
8686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8687   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8688   float arg2 ;
8689
8690   arg1 = (Dali::Vector4 *)jarg1;
8691   arg2 = (float)jarg2;
8692   if (arg1) (arg1)->b = arg2;
8693 }
8694
8695
8696 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8697   float jresult ;
8698   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8699   float result;
8700
8701   arg1 = (Dali::Vector4 *)jarg1;
8702   result = (float) ((arg1)->b);
8703   jresult = result;
8704   return jresult;
8705 }
8706
8707
8708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8709   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8710   float arg2 ;
8711
8712   arg1 = (Dali::Vector4 *)jarg1;
8713   arg2 = (float)jarg2;
8714   if (arg1) (arg1)->p = arg2;
8715 }
8716
8717
8718 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8719   float jresult ;
8720   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8721   float result;
8722
8723   arg1 = (Dali::Vector4 *)jarg1;
8724   result = (float) ((arg1)->p);
8725   jresult = result;
8726   return jresult;
8727 }
8728
8729
8730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8731   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8732   float arg2 ;
8733
8734   arg1 = (Dali::Vector4 *)jarg1;
8735   arg2 = (float)jarg2;
8736   if (arg1) (arg1)->w = arg2;
8737 }
8738
8739
8740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8741   float jresult ;
8742   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8743   float result;
8744
8745   arg1 = (Dali::Vector4 *)jarg1;
8746   result = (float) ((arg1)->w);
8747   jresult = result;
8748   return jresult;
8749 }
8750
8751
8752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8753   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8754   float arg2 ;
8755
8756   arg1 = (Dali::Vector4 *)jarg1;
8757   arg2 = (float)jarg2;
8758   if (arg1) (arg1)->a = arg2;
8759 }
8760
8761
8762 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8763   float jresult ;
8764   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8765   float result;
8766
8767   arg1 = (Dali::Vector4 *)jarg1;
8768   result = (float) ((arg1)->a);
8769   jresult = result;
8770   return jresult;
8771 }
8772
8773
8774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8775   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8776   float arg2 ;
8777
8778   arg1 = (Dali::Vector4 *)jarg1;
8779   arg2 = (float)jarg2;
8780   if (arg1) (arg1)->q = arg2;
8781 }
8782
8783
8784 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8785   float jresult ;
8786   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8787   float result;
8788
8789   arg1 = (Dali::Vector4 *)jarg1;
8790   result = (float) ((arg1)->q);
8791   jresult = result;
8792   return jresult;
8793 }
8794
8795
8796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8797   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8798
8799   arg1 = (Dali::Vector4 *)jarg1;
8800   {
8801     try {
8802       delete arg1;
8803     } catch (std::out_of_range& e) {
8804       {
8805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8806       };
8807     } catch (std::exception& e) {
8808       {
8809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8810       };
8811     } catch (Dali::DaliException e) {
8812       {
8813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8814       };
8815     } catch (...) {
8816       {
8817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8818       };
8819     }
8820   }
8821
8822 }
8823
8824
8825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8826   void * jresult ;
8827   Dali::Vector4 *arg1 = 0 ;
8828   Dali::Vector4 *arg2 = 0 ;
8829   Dali::Vector4 result;
8830
8831   arg1 = (Dali::Vector4 *)jarg1;
8832   if (!arg1) {
8833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8834     return 0;
8835   }
8836   arg2 = (Dali::Vector4 *)jarg2;
8837   if (!arg2) {
8838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8839     return 0;
8840   }
8841   {
8842     try {
8843       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8844     } catch (std::out_of_range& e) {
8845       {
8846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8847       };
8848     } catch (std::exception& e) {
8849       {
8850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8851       };
8852     } catch (Dali::DaliException e) {
8853       {
8854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8855       };
8856     } catch (...) {
8857       {
8858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8859       };
8860     }
8861   }
8862
8863   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8864   return jresult;
8865 }
8866
8867
8868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8869   void * jresult ;
8870   Dali::Vector4 *arg1 = 0 ;
8871   Dali::Vector4 *arg2 = 0 ;
8872   Dali::Vector4 result;
8873
8874   arg1 = (Dali::Vector4 *)jarg1;
8875   if (!arg1) {
8876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8877     return 0;
8878   }
8879   arg2 = (Dali::Vector4 *)jarg2;
8880   if (!arg2) {
8881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8882     return 0;
8883   }
8884   {
8885     try {
8886       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8887     } catch (std::out_of_range& e) {
8888       {
8889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8890       };
8891     } catch (std::exception& e) {
8892       {
8893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8894       };
8895     } catch (Dali::DaliException e) {
8896       {
8897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8898       };
8899     } catch (...) {
8900       {
8901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8902       };
8903     }
8904   }
8905
8906   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8907   return jresult;
8908 }
8909
8910
8911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8912   void * jresult ;
8913   Dali::Vector4 *arg1 = 0 ;
8914   float *arg2 = 0 ;
8915   float *arg3 = 0 ;
8916   float temp2 ;
8917   float temp3 ;
8918   Dali::Vector4 result;
8919
8920   arg1 = (Dali::Vector4 *)jarg1;
8921   if (!arg1) {
8922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8923     return 0;
8924   }
8925   temp2 = (float)jarg2;
8926   arg2 = &temp2;
8927   temp3 = (float)jarg3;
8928   arg3 = &temp3;
8929   {
8930     try {
8931       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8932     } catch (std::out_of_range& e) {
8933       {
8934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8935       };
8936     } catch (std::exception& e) {
8937       {
8938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8939       };
8940     } catch (Dali::DaliException e) {
8941       {
8942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8943       };
8944     } catch (...) {
8945       {
8946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8947       };
8948     }
8949   }
8950
8951   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8952   return jresult;
8953 }
8954
8955
8956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8957   void * jresult ;
8958   Dali::Uint16Pair *result = 0 ;
8959
8960   {
8961     try {
8962       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8963     } catch (std::out_of_range& e) {
8964       {
8965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8966       };
8967     } catch (std::exception& e) {
8968       {
8969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8970       };
8971     } catch (Dali::DaliException e) {
8972       {
8973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8974       };
8975     } catch (...) {
8976       {
8977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8978       };
8979     }
8980   }
8981
8982   jresult = (void *)result;
8983   return jresult;
8984 }
8985
8986
8987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8988   void * jresult ;
8989   uint32_t arg1 ;
8990   uint32_t arg2 ;
8991   Dali::Uint16Pair *result = 0 ;
8992
8993   arg1 = (uint32_t)jarg1;
8994   arg2 = (uint32_t)jarg2;
8995   {
8996     try {
8997       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8998     } catch (std::out_of_range& e) {
8999       {
9000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9001       };
9002     } catch (std::exception& e) {
9003       {
9004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9005       };
9006     } catch (Dali::DaliException e) {
9007       {
9008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9009       };
9010     } catch (...) {
9011       {
9012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9013       };
9014     }
9015   }
9016
9017   jresult = (void *)result;
9018   return jresult;
9019 }
9020
9021
9022 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9023   void * jresult ;
9024   Dali::Uint16Pair *arg1 = 0 ;
9025   Dali::Uint16Pair *result = 0 ;
9026
9027   arg1 = (Dali::Uint16Pair *)jarg1;
9028   if (!arg1) {
9029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9030     return 0;
9031   }
9032   {
9033     try {
9034       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9035     } catch (std::out_of_range& e) {
9036       {
9037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9038       };
9039     } catch (std::exception& e) {
9040       {
9041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9042       };
9043     } catch (Dali::DaliException e) {
9044       {
9045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9046       };
9047     } catch (...) {
9048       {
9049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9050       };
9051     }
9052   }
9053
9054   jresult = (void *)result;
9055   return jresult;
9056 }
9057
9058
9059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9060   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9061   uint16_t arg2 ;
9062
9063   arg1 = (Dali::Uint16Pair *)jarg1;
9064   arg2 = (uint16_t)jarg2;
9065   {
9066     try {
9067       (arg1)->SetWidth(arg2);
9068     } catch (std::out_of_range& e) {
9069       {
9070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9071       };
9072     } catch (std::exception& e) {
9073       {
9074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9075       };
9076     } catch (Dali::DaliException e) {
9077       {
9078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9079       };
9080     } catch (...) {
9081       {
9082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9083       };
9084     }
9085   }
9086
9087 }
9088
9089
9090 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9091   unsigned short jresult ;
9092   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9093   uint16_t result;
9094
9095   arg1 = (Dali::Uint16Pair *)jarg1;
9096   {
9097     try {
9098       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9099     } catch (std::out_of_range& e) {
9100       {
9101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9102       };
9103     } catch (std::exception& e) {
9104       {
9105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9106       };
9107     } catch (Dali::DaliException e) {
9108       {
9109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9110       };
9111     } catch (...) {
9112       {
9113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9114       };
9115     }
9116   }
9117
9118   jresult = result;
9119   return jresult;
9120 }
9121
9122
9123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9124   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9125   uint16_t arg2 ;
9126
9127   arg1 = (Dali::Uint16Pair *)jarg1;
9128   arg2 = (uint16_t)jarg2;
9129   {
9130     try {
9131       (arg1)->SetHeight(arg2);
9132     } catch (std::out_of_range& e) {
9133       {
9134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9135       };
9136     } catch (std::exception& e) {
9137       {
9138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9139       };
9140     } catch (Dali::DaliException e) {
9141       {
9142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9143       };
9144     } catch (...) {
9145       {
9146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9147       };
9148     }
9149   }
9150
9151 }
9152
9153
9154 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9155   unsigned short jresult ;
9156   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9157   uint16_t result;
9158
9159   arg1 = (Dali::Uint16Pair *)jarg1;
9160   {
9161     try {
9162       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9163     } catch (std::out_of_range& e) {
9164       {
9165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9166       };
9167     } catch (std::exception& e) {
9168       {
9169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9170       };
9171     } catch (Dali::DaliException e) {
9172       {
9173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9174       };
9175     } catch (...) {
9176       {
9177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9178       };
9179     }
9180   }
9181
9182   jresult = result;
9183   return jresult;
9184 }
9185
9186
9187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9188   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9189   uint16_t arg2 ;
9190
9191   arg1 = (Dali::Uint16Pair *)jarg1;
9192   arg2 = (uint16_t)jarg2;
9193   {
9194     try {
9195       (arg1)->SetX(arg2);
9196     } catch (std::out_of_range& e) {
9197       {
9198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9199       };
9200     } catch (std::exception& e) {
9201       {
9202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9203       };
9204     } catch (Dali::DaliException e) {
9205       {
9206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9207       };
9208     } catch (...) {
9209       {
9210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9211       };
9212     }
9213   }
9214
9215 }
9216
9217
9218 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9219   unsigned short jresult ;
9220   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9221   uint16_t result;
9222
9223   arg1 = (Dali::Uint16Pair *)jarg1;
9224   {
9225     try {
9226       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9227     } catch (std::out_of_range& e) {
9228       {
9229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9230       };
9231     } catch (std::exception& e) {
9232       {
9233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9234       };
9235     } catch (Dali::DaliException e) {
9236       {
9237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9238       };
9239     } catch (...) {
9240       {
9241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9242       };
9243     }
9244   }
9245
9246   jresult = result;
9247   return jresult;
9248 }
9249
9250
9251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9252   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9253   uint16_t arg2 ;
9254
9255   arg1 = (Dali::Uint16Pair *)jarg1;
9256   arg2 = (uint16_t)jarg2;
9257   {
9258     try {
9259       (arg1)->SetY(arg2);
9260     } catch (std::out_of_range& e) {
9261       {
9262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9263       };
9264     } catch (std::exception& e) {
9265       {
9266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9267       };
9268     } catch (Dali::DaliException e) {
9269       {
9270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9271       };
9272     } catch (...) {
9273       {
9274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9275       };
9276     }
9277   }
9278
9279 }
9280
9281
9282 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9283   unsigned short jresult ;
9284   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9285   uint16_t result;
9286
9287   arg1 = (Dali::Uint16Pair *)jarg1;
9288   {
9289     try {
9290       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9291     } catch (std::out_of_range& e) {
9292       {
9293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9294       };
9295     } catch (std::exception& e) {
9296       {
9297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9298       };
9299     } catch (Dali::DaliException e) {
9300       {
9301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9302       };
9303     } catch (...) {
9304       {
9305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9306       };
9307     }
9308   }
9309
9310   jresult = result;
9311   return jresult;
9312 }
9313
9314
9315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9316   void * jresult ;
9317   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9318   Dali::Uint16Pair *arg2 = 0 ;
9319   Dali::Uint16Pair *result = 0 ;
9320
9321   arg1 = (Dali::Uint16Pair *)jarg1;
9322   arg2 = (Dali::Uint16Pair *)jarg2;
9323   if (!arg2) {
9324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9325     return 0;
9326   }
9327   {
9328     try {
9329       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9330     } catch (std::out_of_range& e) {
9331       {
9332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9333       };
9334     } catch (std::exception& e) {
9335       {
9336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9337       };
9338     } catch (Dali::DaliException e) {
9339       {
9340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9341       };
9342     } catch (...) {
9343       {
9344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9345       };
9346     }
9347   }
9348
9349   jresult = (void *)result;
9350   return jresult;
9351 }
9352
9353
9354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9355   unsigned int jresult ;
9356   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9357   Dali::Uint16Pair *arg2 = 0 ;
9358   bool result;
9359
9360   arg1 = (Dali::Uint16Pair *)jarg1;
9361   arg2 = (Dali::Uint16Pair *)jarg2;
9362   if (!arg2) {
9363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9364     return 0;
9365   }
9366   {
9367     try {
9368       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9369     } catch (std::out_of_range& e) {
9370       {
9371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9372       };
9373     } catch (std::exception& e) {
9374       {
9375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9376       };
9377     } catch (Dali::DaliException e) {
9378       {
9379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9380       };
9381     } catch (...) {
9382       {
9383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9384       };
9385     }
9386   }
9387
9388   jresult = result;
9389   return jresult;
9390 }
9391
9392
9393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9394   unsigned int jresult ;
9395   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9396   Dali::Uint16Pair *arg2 = 0 ;
9397   bool result;
9398
9399   arg1 = (Dali::Uint16Pair *)jarg1;
9400   arg2 = (Dali::Uint16Pair *)jarg2;
9401   if (!arg2) {
9402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9403     return 0;
9404   }
9405   {
9406     try {
9407       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9408     } catch (std::out_of_range& e) {
9409       {
9410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9411       };
9412     } catch (std::exception& e) {
9413       {
9414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9415       };
9416     } catch (Dali::DaliException e) {
9417       {
9418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9419       };
9420     } catch (...) {
9421       {
9422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9423       };
9424     }
9425   }
9426
9427   jresult = result;
9428   return jresult;
9429 }
9430
9431
9432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9433   unsigned int jresult ;
9434   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9435   Dali::Uint16Pair *arg2 = 0 ;
9436   bool result;
9437
9438   arg1 = (Dali::Uint16Pair *)jarg1;
9439   arg2 = (Dali::Uint16Pair *)jarg2;
9440   if (!arg2) {
9441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9442     return 0;
9443   }
9444   {
9445     try {
9446       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9447     } catch (std::out_of_range& e) {
9448       {
9449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9450       };
9451     } catch (std::exception& e) {
9452       {
9453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9454       };
9455     } catch (Dali::DaliException e) {
9456       {
9457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9458       };
9459     } catch (...) {
9460       {
9461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9462       };
9463     }
9464   }
9465
9466   jresult = result;
9467   return jresult;
9468 }
9469
9470
9471 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9472   unsigned int jresult ;
9473   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9474   Dali::Uint16Pair *arg2 = 0 ;
9475   bool result;
9476
9477   arg1 = (Dali::Uint16Pair *)jarg1;
9478   arg2 = (Dali::Uint16Pair *)jarg2;
9479   if (!arg2) {
9480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9481     return 0;
9482   }
9483   {
9484     try {
9485       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9486     } catch (std::out_of_range& e) {
9487       {
9488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9489       };
9490     } catch (std::exception& e) {
9491       {
9492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9493       };
9494     } catch (Dali::DaliException e) {
9495       {
9496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9497       };
9498     } catch (...) {
9499       {
9500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9501       };
9502     }
9503   }
9504
9505   jresult = result;
9506   return jresult;
9507 }
9508
9509
9510 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9511   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9512
9513   arg1 = (Dali::Uint16Pair *)jarg1;
9514   {
9515     try {
9516       delete arg1;
9517     } catch (std::out_of_range& e) {
9518       {
9519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9520       };
9521     } catch (std::exception& e) {
9522       {
9523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9524       };
9525     } catch (Dali::DaliException e) {
9526       {
9527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9528       };
9529     } catch (...) {
9530       {
9531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9532       };
9533     }
9534   }
9535
9536 }
9537
9538
9539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9540   void * jresult ;
9541   Dali::Degree *result = 0 ;
9542
9543   {
9544     try {
9545       result = (Dali::Degree *)new Dali::Degree();
9546     } catch (std::out_of_range& e) {
9547       {
9548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9549       };
9550     } catch (std::exception& e) {
9551       {
9552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9553       };
9554     } catch (Dali::DaliException e) {
9555       {
9556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9557       };
9558     } catch (...) {
9559       {
9560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9561       };
9562     }
9563   }
9564
9565   jresult = (void *)result;
9566   return jresult;
9567 }
9568
9569
9570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9571   void * jresult ;
9572   float arg1 ;
9573   Dali::Degree *result = 0 ;
9574
9575   arg1 = (float)jarg1;
9576   {
9577     try {
9578       result = (Dali::Degree *)new Dali::Degree(arg1);
9579     } catch (std::out_of_range& e) {
9580       {
9581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9582       };
9583     } catch (std::exception& e) {
9584       {
9585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9586       };
9587     } catch (Dali::DaliException e) {
9588       {
9589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9590       };
9591     } catch (...) {
9592       {
9593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9594       };
9595     }
9596   }
9597
9598   jresult = (void *)result;
9599   return jresult;
9600 }
9601
9602
9603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9604   void * jresult ;
9605   Dali::Radian arg1 ;
9606   Dali::Radian *argp1 ;
9607   Dali::Degree *result = 0 ;
9608
9609   argp1 = (Dali::Radian *)jarg1;
9610   if (!argp1) {
9611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9612     return 0;
9613   }
9614   arg1 = *argp1;
9615   {
9616     try {
9617       result = (Dali::Degree *)new Dali::Degree(arg1);
9618     } catch (std::out_of_range& e) {
9619       {
9620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9621       };
9622     } catch (std::exception& e) {
9623       {
9624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9625       };
9626     } catch (Dali::DaliException e) {
9627       {
9628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9629       };
9630     } catch (...) {
9631       {
9632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9633       };
9634     }
9635   }
9636
9637   jresult = (void *)result;
9638   return jresult;
9639 }
9640
9641
9642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9643   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9644   float arg2 ;
9645
9646   arg1 = (Dali::Degree *)jarg1;
9647   arg2 = (float)jarg2;
9648   if (arg1) (arg1)->degree = arg2;
9649 }
9650
9651
9652 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9653   float jresult ;
9654   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9655   float result;
9656
9657   arg1 = (Dali::Degree *)jarg1;
9658   result = (float) ((arg1)->degree);
9659   jresult = result;
9660   return jresult;
9661 }
9662
9663
9664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9665   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9666
9667   arg1 = (Dali::Degree *)jarg1;
9668   {
9669     try {
9670       delete arg1;
9671     } catch (std::out_of_range& e) {
9672       {
9673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9674       };
9675     } catch (std::exception& e) {
9676       {
9677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9678       };
9679     } catch (Dali::DaliException e) {
9680       {
9681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9682       };
9683     } catch (...) {
9684       {
9685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9686       };
9687     }
9688   }
9689
9690 }
9691
9692
9693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9694   void * jresult ;
9695   Dali::Radian *result = 0 ;
9696
9697   result = (Dali::Radian *)&Dali::ANGLE_360;
9698   jresult = (void *)result;
9699   return jresult;
9700 }
9701
9702
9703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9704   void * jresult ;
9705   Dali::Radian *result = 0 ;
9706
9707   result = (Dali::Radian *)&Dali::ANGLE_315;
9708   jresult = (void *)result;
9709   return jresult;
9710 }
9711
9712
9713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9714   void * jresult ;
9715   Dali::Radian *result = 0 ;
9716
9717   result = (Dali::Radian *)&Dali::ANGLE_270;
9718   jresult = (void *)result;
9719   return jresult;
9720 }
9721
9722
9723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9724   void * jresult ;
9725   Dali::Radian *result = 0 ;
9726
9727   result = (Dali::Radian *)&Dali::ANGLE_225;
9728   jresult = (void *)result;
9729   return jresult;
9730 }
9731
9732
9733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9734   void * jresult ;
9735   Dali::Radian *result = 0 ;
9736
9737   result = (Dali::Radian *)&Dali::ANGLE_180;
9738   jresult = (void *)result;
9739   return jresult;
9740 }
9741
9742
9743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9744   void * jresult ;
9745   Dali::Radian *result = 0 ;
9746
9747   result = (Dali::Radian *)&Dali::ANGLE_135;
9748   jresult = (void *)result;
9749   return jresult;
9750 }
9751
9752
9753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9754   void * jresult ;
9755   Dali::Radian *result = 0 ;
9756
9757   result = (Dali::Radian *)&Dali::ANGLE_120;
9758   jresult = (void *)result;
9759   return jresult;
9760 }
9761
9762
9763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9764   void * jresult ;
9765   Dali::Radian *result = 0 ;
9766
9767   result = (Dali::Radian *)&Dali::ANGLE_90;
9768   jresult = (void *)result;
9769   return jresult;
9770 }
9771
9772
9773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9774   void * jresult ;
9775   Dali::Radian *result = 0 ;
9776
9777   result = (Dali::Radian *)&Dali::ANGLE_60;
9778   jresult = (void *)result;
9779   return jresult;
9780 }
9781
9782
9783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9784   void * jresult ;
9785   Dali::Radian *result = 0 ;
9786
9787   result = (Dali::Radian *)&Dali::ANGLE_45;
9788   jresult = (void *)result;
9789   return jresult;
9790 }
9791
9792
9793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9794   void * jresult ;
9795   Dali::Radian *result = 0 ;
9796
9797   result = (Dali::Radian *)&Dali::ANGLE_30;
9798   jresult = (void *)result;
9799   return jresult;
9800 }
9801
9802
9803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9804   void * jresult ;
9805   Dali::Radian *result = 0 ;
9806
9807   result = (Dali::Radian *)&Dali::ANGLE_0;
9808   jresult = (void *)result;
9809   return jresult;
9810 }
9811
9812
9813 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9814   unsigned int jresult ;
9815   Dali::Degree *arg1 = 0 ;
9816   Dali::Degree *arg2 = 0 ;
9817   bool result;
9818
9819   arg1 = (Dali::Degree *)jarg1;
9820   if (!arg1) {
9821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9822     return 0;
9823   }
9824   arg2 = (Dali::Degree *)jarg2;
9825   if (!arg2) {
9826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9827     return 0;
9828   }
9829   {
9830     try {
9831       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9832     } catch (std::out_of_range& e) {
9833       {
9834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9835       };
9836     } catch (std::exception& e) {
9837       {
9838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9839       };
9840     } catch (Dali::DaliException e) {
9841       {
9842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9843       };
9844     } catch (...) {
9845       {
9846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9847       };
9848     }
9849   }
9850
9851   jresult = result;
9852   return jresult;
9853 }
9854
9855
9856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9857   unsigned int jresult ;
9858   Dali::Degree *arg1 = 0 ;
9859   Dali::Degree *arg2 = 0 ;
9860   bool result;
9861
9862   arg1 = (Dali::Degree *)jarg1;
9863   if (!arg1) {
9864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9865     return 0;
9866   }
9867   arg2 = (Dali::Degree *)jarg2;
9868   if (!arg2) {
9869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9870     return 0;
9871   }
9872   {
9873     try {
9874       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9875     } catch (std::out_of_range& e) {
9876       {
9877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9878       };
9879     } catch (std::exception& e) {
9880       {
9881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9882       };
9883     } catch (Dali::DaliException e) {
9884       {
9885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9886       };
9887     } catch (...) {
9888       {
9889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9890       };
9891     }
9892   }
9893
9894   jresult = result;
9895   return jresult;
9896 }
9897
9898
9899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9900   void * jresult ;
9901   Dali::Degree arg1 ;
9902   float arg2 ;
9903   float arg3 ;
9904   Dali::Degree *argp1 ;
9905   Dali::Degree result;
9906
9907   argp1 = (Dali::Degree *)jarg1;
9908   if (!argp1) {
9909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9910     return 0;
9911   }
9912   arg1 = *argp1;
9913   arg2 = (float)jarg2;
9914   arg3 = (float)jarg3;
9915   {
9916     try {
9917       result = Dali::Clamp(arg1,arg2,arg3);
9918     } catch (std::out_of_range& e) {
9919       {
9920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9921       };
9922     } catch (std::exception& e) {
9923       {
9924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9925       };
9926     } catch (Dali::DaliException e) {
9927       {
9928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9929       };
9930     } catch (...) {
9931       {
9932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9933       };
9934     }
9935   }
9936
9937   jresult = new Dali::Degree((const Dali::Degree &)result);
9938   return jresult;
9939 }
9940
9941
9942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9943   void * jresult ;
9944   Dali::Radian *result = 0 ;
9945
9946   {
9947     try {
9948       result = (Dali::Radian *)new Dali::Radian();
9949     } catch (std::out_of_range& e) {
9950       {
9951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9952       };
9953     } catch (std::exception& e) {
9954       {
9955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9956       };
9957     } catch (Dali::DaliException e) {
9958       {
9959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9960       };
9961     } catch (...) {
9962       {
9963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9964       };
9965     }
9966   }
9967
9968   jresult = (void *)result;
9969   return jresult;
9970 }
9971
9972
9973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9974   void * jresult ;
9975   float arg1 ;
9976   Dali::Radian *result = 0 ;
9977
9978   arg1 = (float)jarg1;
9979   {
9980     try {
9981       result = (Dali::Radian *)new Dali::Radian(arg1);
9982     } catch (std::out_of_range& e) {
9983       {
9984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9985       };
9986     } catch (std::exception& e) {
9987       {
9988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9989       };
9990     } catch (Dali::DaliException e) {
9991       {
9992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9993       };
9994     } catch (...) {
9995       {
9996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9997       };
9998     }
9999   }
10000
10001   jresult = (void *)result;
10002   return jresult;
10003 }
10004
10005
10006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10007   void * jresult ;
10008   Dali::Degree arg1 ;
10009   Dali::Degree *argp1 ;
10010   Dali::Radian *result = 0 ;
10011
10012   argp1 = (Dali::Degree *)jarg1;
10013   if (!argp1) {
10014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10015     return 0;
10016   }
10017   arg1 = *argp1;
10018   {
10019     try {
10020       result = (Dali::Radian *)new Dali::Radian(arg1);
10021     } catch (std::out_of_range& e) {
10022       {
10023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10024       };
10025     } catch (std::exception& e) {
10026       {
10027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10028       };
10029     } catch (Dali::DaliException e) {
10030       {
10031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10032       };
10033     } catch (...) {
10034       {
10035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10036       };
10037     }
10038   }
10039
10040   jresult = (void *)result;
10041   return jresult;
10042 }
10043
10044
10045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10046   void * jresult ;
10047   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10048   float arg2 ;
10049   Dali::Radian *result = 0 ;
10050
10051   arg1 = (Dali::Radian *)jarg1;
10052   arg2 = (float)jarg2;
10053   {
10054     try {
10055       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10056     } catch (std::out_of_range& e) {
10057       {
10058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10059       };
10060     } catch (std::exception& e) {
10061       {
10062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10063       };
10064     } catch (Dali::DaliException e) {
10065       {
10066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10067       };
10068     } catch (...) {
10069       {
10070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10071       };
10072     }
10073   }
10074
10075   jresult = (void *)result;
10076   return jresult;
10077 }
10078
10079
10080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10081   void * jresult ;
10082   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10083   Dali::Degree arg2 ;
10084   Dali::Degree *argp2 ;
10085   Dali::Radian *result = 0 ;
10086
10087   arg1 = (Dali::Radian *)jarg1;
10088   argp2 = (Dali::Degree *)jarg2;
10089   if (!argp2) {
10090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10091     return 0;
10092   }
10093   arg2 = *argp2;
10094   {
10095     try {
10096       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10097     } catch (std::out_of_range& e) {
10098       {
10099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10100       };
10101     } catch (std::exception& e) {
10102       {
10103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10104       };
10105     } catch (Dali::DaliException e) {
10106       {
10107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10108       };
10109     } catch (...) {
10110       {
10111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10112       };
10113     }
10114   }
10115
10116   jresult = (void *)result;
10117   return jresult;
10118 }
10119
10120
10121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10122   float jresult ;
10123   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10124   float result;
10125
10126   arg1 = (Dali::Radian *)jarg1;
10127   {
10128     try {
10129       result = (float)((Dali::Radian const *)arg1)->operator float();
10130     } catch (std::out_of_range& e) {
10131       {
10132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10133       };
10134     } catch (std::exception& e) {
10135       {
10136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10137       };
10138     } catch (Dali::DaliException e) {
10139       {
10140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10141       };
10142     } catch (...) {
10143       {
10144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10145       };
10146     }
10147   }
10148
10149   jresult = result;
10150   return jresult;
10151 }
10152
10153
10154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10155   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10156   float arg2 ;
10157
10158   arg1 = (Dali::Radian *)jarg1;
10159   arg2 = (float)jarg2;
10160   if (arg1) (arg1)->radian = arg2;
10161 }
10162
10163
10164 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10165   float jresult ;
10166   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10167   float result;
10168
10169   arg1 = (Dali::Radian *)jarg1;
10170   result = (float) ((arg1)->radian);
10171   jresult = result;
10172   return jresult;
10173 }
10174
10175
10176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10177   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10178
10179   arg1 = (Dali::Radian *)jarg1;
10180   {
10181     try {
10182       delete arg1;
10183     } catch (std::out_of_range& e) {
10184       {
10185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10186       };
10187     } catch (std::exception& e) {
10188       {
10189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10190       };
10191     } catch (Dali::DaliException e) {
10192       {
10193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10194       };
10195     } catch (...) {
10196       {
10197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10198       };
10199     }
10200   }
10201
10202 }
10203
10204
10205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10206   unsigned int jresult ;
10207   Dali::Radian arg1 ;
10208   Dali::Radian arg2 ;
10209   Dali::Radian *argp1 ;
10210   Dali::Radian *argp2 ;
10211   bool result;
10212
10213   argp1 = (Dali::Radian *)jarg1;
10214   if (!argp1) {
10215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10216     return 0;
10217   }
10218   arg1 = *argp1;
10219   argp2 = (Dali::Radian *)jarg2;
10220   if (!argp2) {
10221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10222     return 0;
10223   }
10224   arg2 = *argp2;
10225   {
10226     try {
10227       result = (bool)Dali::operator ==(arg1,arg2);
10228     } catch (std::out_of_range& e) {
10229       {
10230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10231       };
10232     } catch (std::exception& e) {
10233       {
10234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (Dali::DaliException e) {
10237       {
10238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10239       };
10240     } catch (...) {
10241       {
10242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10243       };
10244     }
10245   }
10246
10247   jresult = result;
10248   return jresult;
10249 }
10250
10251
10252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10253   unsigned int jresult ;
10254   Dali::Radian arg1 ;
10255   Dali::Radian arg2 ;
10256   Dali::Radian *argp1 ;
10257   Dali::Radian *argp2 ;
10258   bool result;
10259
10260   argp1 = (Dali::Radian *)jarg1;
10261   if (!argp1) {
10262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10263     return 0;
10264   }
10265   arg1 = *argp1;
10266   argp2 = (Dali::Radian *)jarg2;
10267   if (!argp2) {
10268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10269     return 0;
10270   }
10271   arg2 = *argp2;
10272   {
10273     try {
10274       result = (bool)Dali::operator !=(arg1,arg2);
10275     } catch (std::out_of_range& e) {
10276       {
10277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10278       };
10279     } catch (std::exception& e) {
10280       {
10281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (Dali::DaliException e) {
10284       {
10285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10286       };
10287     } catch (...) {
10288       {
10289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10290       };
10291     }
10292   }
10293
10294   jresult = result;
10295   return jresult;
10296 }
10297
10298
10299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10300   unsigned int jresult ;
10301   Dali::Radian arg1 ;
10302   Dali::Degree arg2 ;
10303   Dali::Radian *argp1 ;
10304   Dali::Degree *argp2 ;
10305   bool result;
10306
10307   argp1 = (Dali::Radian *)jarg1;
10308   if (!argp1) {
10309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10310     return 0;
10311   }
10312   arg1 = *argp1;
10313   argp2 = (Dali::Degree *)jarg2;
10314   if (!argp2) {
10315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10316     return 0;
10317   }
10318   arg2 = *argp2;
10319   {
10320     try {
10321       result = (bool)Dali::operator ==(arg1,arg2);
10322     } catch (std::out_of_range& e) {
10323       {
10324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10325       };
10326     } catch (std::exception& e) {
10327       {
10328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (Dali::DaliException e) {
10331       {
10332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10333       };
10334     } catch (...) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10337       };
10338     }
10339   }
10340
10341   jresult = result;
10342   return jresult;
10343 }
10344
10345
10346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10347   unsigned int jresult ;
10348   Dali::Radian arg1 ;
10349   Dali::Degree arg2 ;
10350   Dali::Radian *argp1 ;
10351   Dali::Degree *argp2 ;
10352   bool result;
10353
10354   argp1 = (Dali::Radian *)jarg1;
10355   if (!argp1) {
10356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10357     return 0;
10358   }
10359   arg1 = *argp1;
10360   argp2 = (Dali::Degree *)jarg2;
10361   if (!argp2) {
10362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10363     return 0;
10364   }
10365   arg2 = *argp2;
10366   {
10367     try {
10368       result = (bool)Dali::operator !=(arg1,arg2);
10369     } catch (std::out_of_range& e) {
10370       {
10371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10372       };
10373     } catch (std::exception& e) {
10374       {
10375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (Dali::DaliException e) {
10378       {
10379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10380       };
10381     } catch (...) {
10382       {
10383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10384       };
10385     }
10386   }
10387
10388   jresult = result;
10389   return jresult;
10390 }
10391
10392
10393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10394   unsigned int jresult ;
10395   Dali::Degree arg1 ;
10396   Dali::Radian arg2 ;
10397   Dali::Degree *argp1 ;
10398   Dali::Radian *argp2 ;
10399   bool result;
10400
10401   argp1 = (Dali::Degree *)jarg1;
10402   if (!argp1) {
10403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10404     return 0;
10405   }
10406   arg1 = *argp1;
10407   argp2 = (Dali::Radian *)jarg2;
10408   if (!argp2) {
10409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10410     return 0;
10411   }
10412   arg2 = *argp2;
10413   {
10414     try {
10415       result = (bool)Dali::operator ==(arg1,arg2);
10416     } catch (std::out_of_range& e) {
10417       {
10418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10419       };
10420     } catch (std::exception& e) {
10421       {
10422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (Dali::DaliException e) {
10425       {
10426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10427       };
10428     } catch (...) {
10429       {
10430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10431       };
10432     }
10433   }
10434
10435   jresult = result;
10436   return jresult;
10437 }
10438
10439
10440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10441   unsigned int jresult ;
10442   Dali::Degree arg1 ;
10443   Dali::Radian arg2 ;
10444   Dali::Degree *argp1 ;
10445   Dali::Radian *argp2 ;
10446   bool result;
10447
10448   argp1 = (Dali::Degree *)jarg1;
10449   if (!argp1) {
10450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10451     return 0;
10452   }
10453   arg1 = *argp1;
10454   argp2 = (Dali::Radian *)jarg2;
10455   if (!argp2) {
10456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10457     return 0;
10458   }
10459   arg2 = *argp2;
10460   {
10461     try {
10462       result = (bool)Dali::operator !=(arg1,arg2);
10463     } catch (std::out_of_range& e) {
10464       {
10465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10466       };
10467     } catch (std::exception& e) {
10468       {
10469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10470       };
10471     } catch (Dali::DaliException e) {
10472       {
10473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10474       };
10475     } catch (...) {
10476       {
10477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10478       };
10479     }
10480   }
10481
10482   jresult = result;
10483   return jresult;
10484 }
10485
10486
10487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10488   unsigned int jresult ;
10489   Dali::Radian arg1 ;
10490   Dali::Radian arg2 ;
10491   Dali::Radian *argp1 ;
10492   Dali::Radian *argp2 ;
10493   bool result;
10494
10495   argp1 = (Dali::Radian *)jarg1;
10496   if (!argp1) {
10497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10498     return 0;
10499   }
10500   arg1 = *argp1;
10501   argp2 = (Dali::Radian *)jarg2;
10502   if (!argp2) {
10503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10504     return 0;
10505   }
10506   arg2 = *argp2;
10507   {
10508     try {
10509       result = (bool)Dali::operator >(arg1,arg2);
10510     } catch (std::out_of_range& e) {
10511       {
10512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10513       };
10514     } catch (std::exception& e) {
10515       {
10516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (Dali::DaliException e) {
10519       {
10520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10521       };
10522     } catch (...) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10525       };
10526     }
10527   }
10528
10529   jresult = result;
10530   return jresult;
10531 }
10532
10533
10534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10535   unsigned int jresult ;
10536   Dali::Radian arg1 ;
10537   Dali::Degree arg2 ;
10538   Dali::Radian *argp1 ;
10539   Dali::Degree *argp2 ;
10540   bool result;
10541
10542   argp1 = (Dali::Radian *)jarg1;
10543   if (!argp1) {
10544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10545     return 0;
10546   }
10547   arg1 = *argp1;
10548   argp2 = (Dali::Degree *)jarg2;
10549   if (!argp2) {
10550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10551     return 0;
10552   }
10553   arg2 = *argp2;
10554   {
10555     try {
10556       result = (bool)Dali::operator >(arg1,arg2);
10557     } catch (std::out_of_range& e) {
10558       {
10559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10560       };
10561     } catch (std::exception& e) {
10562       {
10563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10564       };
10565     } catch (Dali::DaliException e) {
10566       {
10567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10568       };
10569     } catch (...) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10572       };
10573     }
10574   }
10575
10576   jresult = result;
10577   return jresult;
10578 }
10579
10580
10581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10582   unsigned int jresult ;
10583   Dali::Degree arg1 ;
10584   Dali::Radian arg2 ;
10585   Dali::Degree *argp1 ;
10586   Dali::Radian *argp2 ;
10587   bool result;
10588
10589   argp1 = (Dali::Degree *)jarg1;
10590   if (!argp1) {
10591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10592     return 0;
10593   }
10594   arg1 = *argp1;
10595   argp2 = (Dali::Radian *)jarg2;
10596   if (!argp2) {
10597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10598     return 0;
10599   }
10600   arg2 = *argp2;
10601   {
10602     try {
10603       result = (bool)Dali::operator >(arg1,arg2);
10604     } catch (std::out_of_range& e) {
10605       {
10606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10607       };
10608     } catch (std::exception& e) {
10609       {
10610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10611       };
10612     } catch (Dali::DaliException e) {
10613       {
10614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10615       };
10616     } catch (...) {
10617       {
10618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10619       };
10620     }
10621   }
10622
10623   jresult = result;
10624   return jresult;
10625 }
10626
10627
10628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10629   unsigned int jresult ;
10630   Dali::Radian arg1 ;
10631   Dali::Radian arg2 ;
10632   Dali::Radian *argp1 ;
10633   Dali::Radian *argp2 ;
10634   bool result;
10635
10636   argp1 = (Dali::Radian *)jarg1;
10637   if (!argp1) {
10638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10639     return 0;
10640   }
10641   arg1 = *argp1;
10642   argp2 = (Dali::Radian *)jarg2;
10643   if (!argp2) {
10644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10645     return 0;
10646   }
10647   arg2 = *argp2;
10648   {
10649     try {
10650       result = (bool)Dali::operator <(arg1,arg2);
10651     } catch (std::out_of_range& e) {
10652       {
10653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10654       };
10655     } catch (std::exception& e) {
10656       {
10657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (Dali::DaliException e) {
10660       {
10661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10662       };
10663     } catch (...) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10666       };
10667     }
10668   }
10669
10670   jresult = result;
10671   return jresult;
10672 }
10673
10674
10675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10676   unsigned int jresult ;
10677   Dali::Radian arg1 ;
10678   Dali::Degree arg2 ;
10679   Dali::Radian *argp1 ;
10680   Dali::Degree *argp2 ;
10681   bool result;
10682
10683   argp1 = (Dali::Radian *)jarg1;
10684   if (!argp1) {
10685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10686     return 0;
10687   }
10688   arg1 = *argp1;
10689   argp2 = (Dali::Degree *)jarg2;
10690   if (!argp2) {
10691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10692     return 0;
10693   }
10694   arg2 = *argp2;
10695   {
10696     try {
10697       result = (bool)Dali::operator <(arg1,arg2);
10698     } catch (std::out_of_range& e) {
10699       {
10700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10701       };
10702     } catch (std::exception& e) {
10703       {
10704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10705       };
10706     } catch (Dali::DaliException e) {
10707       {
10708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10709       };
10710     } catch (...) {
10711       {
10712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10713       };
10714     }
10715   }
10716
10717   jresult = result;
10718   return jresult;
10719 }
10720
10721
10722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10723   unsigned int jresult ;
10724   Dali::Degree arg1 ;
10725   Dali::Radian arg2 ;
10726   Dali::Degree *argp1 ;
10727   Dali::Radian *argp2 ;
10728   bool result;
10729
10730   argp1 = (Dali::Degree *)jarg1;
10731   if (!argp1) {
10732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10733     return 0;
10734   }
10735   arg1 = *argp1;
10736   argp2 = (Dali::Radian *)jarg2;
10737   if (!argp2) {
10738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10739     return 0;
10740   }
10741   arg2 = *argp2;
10742   {
10743     try {
10744       result = (bool)Dali::operator <(arg1,arg2);
10745     } catch (std::out_of_range& e) {
10746       {
10747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10748       };
10749     } catch (std::exception& e) {
10750       {
10751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10752       };
10753     } catch (Dali::DaliException e) {
10754       {
10755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10756       };
10757     } catch (...) {
10758       {
10759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10760       };
10761     }
10762   }
10763
10764   jresult = result;
10765   return jresult;
10766 }
10767
10768
10769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10770   void * jresult ;
10771   Dali::Radian arg1 ;
10772   float arg2 ;
10773   Dali::Radian *argp1 ;
10774   Dali::Radian result;
10775
10776   argp1 = (Dali::Radian *)jarg1;
10777   if (!argp1) {
10778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10779     return 0;
10780   }
10781   arg1 = *argp1;
10782   arg2 = (float)jarg2;
10783   {
10784     try {
10785       result = Dali::operator *(arg1,arg2);
10786     } catch (std::out_of_range& e) {
10787       {
10788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10789       };
10790     } catch (std::exception& e) {
10791       {
10792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10793       };
10794     } catch (Dali::DaliException e) {
10795       {
10796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10797       };
10798     } catch (...) {
10799       {
10800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10801       };
10802     }
10803   }
10804
10805   jresult = new Dali::Radian((const Dali::Radian &)result);
10806   return jresult;
10807 }
10808
10809
10810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10811   void * jresult ;
10812   Dali::Radian arg1 ;
10813   Dali::Radian *argp1 ;
10814   Dali::Radian result;
10815
10816   argp1 = (Dali::Radian *)jarg1;
10817   if (!argp1) {
10818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10819     return 0;
10820   }
10821   arg1 = *argp1;
10822   {
10823     try {
10824       result = Dali::operator -(arg1);
10825     } catch (std::out_of_range& e) {
10826       {
10827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10828       };
10829     } catch (std::exception& e) {
10830       {
10831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10832       };
10833     } catch (Dali::DaliException e) {
10834       {
10835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10836       };
10837     } catch (...) {
10838       {
10839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10840       };
10841     }
10842   }
10843
10844   jresult = new Dali::Radian((const Dali::Radian &)result);
10845   return jresult;
10846 }
10847
10848
10849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10850   void * jresult ;
10851   Dali::Radian arg1 ;
10852   float arg2 ;
10853   float arg3 ;
10854   Dali::Radian *argp1 ;
10855   Dali::Radian result;
10856
10857   argp1 = (Dali::Radian *)jarg1;
10858   if (!argp1) {
10859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10860     return 0;
10861   }
10862   arg1 = *argp1;
10863   arg2 = (float)jarg2;
10864   arg3 = (float)jarg3;
10865   {
10866     try {
10867       result = Dali::Clamp(arg1,arg2,arg3);
10868     } catch (std::out_of_range& e) {
10869       {
10870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10871       };
10872     } catch (std::exception& e) {
10873       {
10874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10875       };
10876     } catch (Dali::DaliException e) {
10877       {
10878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10879       };
10880     } catch (...) {
10881       {
10882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10883       };
10884     }
10885   }
10886
10887   jresult = new Dali::Radian((const Dali::Radian &)result);
10888   return jresult;
10889 }
10890
10891
10892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10893   void * jresult ;
10894   Dali::Quaternion *result = 0 ;
10895
10896   {
10897     try {
10898       result = (Dali::Quaternion *)new Dali::Quaternion();
10899     } catch (std::out_of_range& e) {
10900       {
10901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10902       };
10903     } catch (std::exception& e) {
10904       {
10905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10906       };
10907     } catch (Dali::DaliException e) {
10908       {
10909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10910       };
10911     } catch (...) {
10912       {
10913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10914       };
10915     }
10916   }
10917
10918   jresult = (void *)result;
10919   return jresult;
10920 }
10921
10922
10923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10924   void * jresult ;
10925   Dali::Radian arg1 ;
10926   Dali::Vector3 *arg2 = 0 ;
10927   Dali::Radian *argp1 ;
10928   Dali::Quaternion *result = 0 ;
10929
10930   argp1 = (Dali::Radian *)jarg1;
10931   if (!argp1) {
10932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10933     return 0;
10934   }
10935   arg1 = *argp1;
10936   arg2 = (Dali::Vector3 *)jarg2;
10937   if (!arg2) {
10938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10939     return 0;
10940   }
10941   {
10942     try {
10943       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10944     } catch (std::out_of_range& e) {
10945       {
10946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10947       };
10948     } catch (std::exception& e) {
10949       {
10950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10951       };
10952     } catch (Dali::DaliException e) {
10953       {
10954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10955       };
10956     } catch (...) {
10957       {
10958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10959       };
10960     }
10961   }
10962
10963   jresult = (void *)result;
10964   return jresult;
10965 }
10966
10967
10968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10969   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10970
10971   arg1 = (Dali::Quaternion *)jarg1;
10972   {
10973     try {
10974       delete arg1;
10975     } catch (std::out_of_range& e) {
10976       {
10977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10978       };
10979     } catch (std::exception& e) {
10980       {
10981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10982       };
10983     } catch (Dali::DaliException e) {
10984       {
10985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10986       };
10987     } catch (...) {
10988       {
10989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10990       };
10991     }
10992   }
10993
10994 }
10995
10996
10997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10998   void * jresult ;
10999   Dali::Quaternion *result = 0 ;
11000
11001   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11002   jresult = (void *)result;
11003   return jresult;
11004 }
11005
11006
11007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11008   unsigned int jresult ;
11009   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11010   bool result;
11011
11012   arg1 = (Dali::Quaternion *)jarg1;
11013   {
11014     try {
11015       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11016     } catch (std::out_of_range& e) {
11017       {
11018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11019       };
11020     } catch (std::exception& e) {
11021       {
11022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11023       };
11024     } catch (Dali::DaliException e) {
11025       {
11026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11027       };
11028     } catch (...) {
11029       {
11030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11031       };
11032     }
11033   }
11034
11035   jresult = result;
11036   return jresult;
11037 }
11038
11039
11040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11041   unsigned int jresult ;
11042   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11043   Dali::Vector3 *arg2 = 0 ;
11044   Dali::Radian *arg3 = 0 ;
11045   bool result;
11046
11047   arg1 = (Dali::Quaternion *)jarg1;
11048   arg2 = (Dali::Vector3 *)jarg2;
11049   if (!arg2) {
11050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11051     return 0;
11052   }
11053   arg3 = (Dali::Radian *)jarg3;
11054   if (!arg3) {
11055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11056     return 0;
11057   }
11058   {
11059     try {
11060       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11061     } catch (std::out_of_range& e) {
11062       {
11063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11064       };
11065     } catch (std::exception& e) {
11066       {
11067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11068       };
11069     } catch (Dali::DaliException e) {
11070       {
11071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11072       };
11073     } catch (...) {
11074       {
11075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11076       };
11077     }
11078   }
11079
11080   jresult = result;
11081   return jresult;
11082 }
11083
11084
11085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11086   void * jresult ;
11087   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11088   Dali::Quaternion *arg2 = 0 ;
11089   Dali::Quaternion result;
11090
11091   arg1 = (Dali::Quaternion *)jarg1;
11092   arg2 = (Dali::Quaternion *)jarg2;
11093   if (!arg2) {
11094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11095     return 0;
11096   }
11097   {
11098     try {
11099       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11100     } catch (std::out_of_range& e) {
11101       {
11102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11103       };
11104     } catch (std::exception& e) {
11105       {
11106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11107       };
11108     } catch (Dali::DaliException e) {
11109       {
11110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11111       };
11112     } catch (...) {
11113       {
11114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11115       };
11116     }
11117   }
11118
11119   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11120   return jresult;
11121 }
11122
11123
11124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11125   void * jresult ;
11126   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11127   Dali::Quaternion *arg2 = 0 ;
11128   Dali::Quaternion result;
11129
11130   arg1 = (Dali::Quaternion *)jarg1;
11131   arg2 = (Dali::Quaternion *)jarg2;
11132   if (!arg2) {
11133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11134     return 0;
11135   }
11136   {
11137     try {
11138       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11139     } catch (std::out_of_range& e) {
11140       {
11141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11142       };
11143     } catch (std::exception& e) {
11144       {
11145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11146       };
11147     } catch (Dali::DaliException e) {
11148       {
11149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11150       };
11151     } catch (...) {
11152       {
11153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11154       };
11155     }
11156   }
11157
11158   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11159   return jresult;
11160 }
11161
11162
11163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11164   void * jresult ;
11165   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11166   Dali::Quaternion *arg2 = 0 ;
11167   Dali::Quaternion result;
11168
11169   arg1 = (Dali::Quaternion *)jarg1;
11170   arg2 = (Dali::Quaternion *)jarg2;
11171   if (!arg2) {
11172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11173     return 0;
11174   }
11175   {
11176     try {
11177       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11178     } catch (std::out_of_range& e) {
11179       {
11180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11181       };
11182     } catch (std::exception& e) {
11183       {
11184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11185       };
11186     } catch (Dali::DaliException e) {
11187       {
11188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11189       };
11190     } catch (...) {
11191       {
11192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11193       };
11194     }
11195   }
11196
11197   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11198   return jresult;
11199 }
11200
11201
11202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11203   void * jresult ;
11204   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11205   Dali::Vector3 *arg2 = 0 ;
11206   Dali::Vector3 result;
11207
11208   arg1 = (Dali::Quaternion *)jarg1;
11209   arg2 = (Dali::Vector3 *)jarg2;
11210   if (!arg2) {
11211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11212     return 0;
11213   }
11214   {
11215     try {
11216       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11217     } catch (std::out_of_range& e) {
11218       {
11219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11220       };
11221     } catch (std::exception& e) {
11222       {
11223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11224       };
11225     } catch (Dali::DaliException e) {
11226       {
11227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11228       };
11229     } catch (...) {
11230       {
11231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11232       };
11233     }
11234   }
11235
11236   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11237   return jresult;
11238 }
11239
11240
11241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11242   void * jresult ;
11243   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11244   Dali::Quaternion *arg2 = 0 ;
11245   Dali::Quaternion result;
11246
11247   arg1 = (Dali::Quaternion *)jarg1;
11248   arg2 = (Dali::Quaternion *)jarg2;
11249   if (!arg2) {
11250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11251     return 0;
11252   }
11253   {
11254     try {
11255       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11256     } catch (std::out_of_range& e) {
11257       {
11258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11259       };
11260     } catch (std::exception& e) {
11261       {
11262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11263       };
11264     } catch (Dali::DaliException e) {
11265       {
11266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11267       };
11268     } catch (...) {
11269       {
11270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11271       };
11272     }
11273   }
11274
11275   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11276   return jresult;
11277 }
11278
11279
11280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11281   void * jresult ;
11282   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11283   float arg2 ;
11284   Dali::Quaternion result;
11285
11286   arg1 = (Dali::Quaternion *)jarg1;
11287   arg2 = (float)jarg2;
11288   {
11289     try {
11290       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11291     } catch (std::out_of_range& e) {
11292       {
11293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11294       };
11295     } catch (std::exception& e) {
11296       {
11297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11298       };
11299     } catch (Dali::DaliException e) {
11300       {
11301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11302       };
11303     } catch (...) {
11304       {
11305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11306       };
11307     }
11308   }
11309
11310   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11311   return jresult;
11312 }
11313
11314
11315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11316   void * jresult ;
11317   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11318   float arg2 ;
11319   Dali::Quaternion result;
11320
11321   arg1 = (Dali::Quaternion *)jarg1;
11322   arg2 = (float)jarg2;
11323   {
11324     try {
11325       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11326     } catch (std::out_of_range& e) {
11327       {
11328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11329       };
11330     } catch (std::exception& e) {
11331       {
11332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11333       };
11334     } catch (Dali::DaliException e) {
11335       {
11336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11337       };
11338     } catch (...) {
11339       {
11340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11341       };
11342     }
11343   }
11344
11345   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11346   return jresult;
11347 }
11348
11349
11350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11351   void * jresult ;
11352   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11353   Dali::Quaternion result;
11354
11355   arg1 = (Dali::Quaternion *)jarg1;
11356   {
11357     try {
11358       result = ((Dali::Quaternion const *)arg1)->operator -();
11359     } catch (std::out_of_range& e) {
11360       {
11361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11362       };
11363     } catch (std::exception& e) {
11364       {
11365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11366       };
11367     } catch (Dali::DaliException e) {
11368       {
11369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11370       };
11371     } catch (...) {
11372       {
11373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11374       };
11375     }
11376   }
11377
11378   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11379   return jresult;
11380 }
11381
11382
11383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11384   void * jresult ;
11385   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11386   Dali::Quaternion *arg2 = 0 ;
11387   Dali::Quaternion *result = 0 ;
11388
11389   arg1 = (Dali::Quaternion *)jarg1;
11390   arg2 = (Dali::Quaternion *)jarg2;
11391   if (!arg2) {
11392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11393     return 0;
11394   }
11395   {
11396     try {
11397       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11398     } catch (std::out_of_range& e) {
11399       {
11400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11401       };
11402     } catch (std::exception& e) {
11403       {
11404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11405       };
11406     } catch (Dali::DaliException e) {
11407       {
11408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11409       };
11410     } catch (...) {
11411       {
11412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11413       };
11414     }
11415   }
11416
11417   jresult = (void *)result;
11418   return jresult;
11419 }
11420
11421
11422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11423   void * jresult ;
11424   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11425   Dali::Quaternion *arg2 = 0 ;
11426   Dali::Quaternion *result = 0 ;
11427
11428   arg1 = (Dali::Quaternion *)jarg1;
11429   arg2 = (Dali::Quaternion *)jarg2;
11430   if (!arg2) {
11431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11432     return 0;
11433   }
11434   {
11435     try {
11436       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11437     } catch (std::out_of_range& e) {
11438       {
11439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11440       };
11441     } catch (std::exception& e) {
11442       {
11443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11444       };
11445     } catch (Dali::DaliException e) {
11446       {
11447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11448       };
11449     } catch (...) {
11450       {
11451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11452       };
11453     }
11454   }
11455
11456   jresult = (void *)result;
11457   return jresult;
11458 }
11459
11460
11461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11462   void * jresult ;
11463   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11464   Dali::Quaternion *arg2 = 0 ;
11465   Dali::Quaternion *result = 0 ;
11466
11467   arg1 = (Dali::Quaternion *)jarg1;
11468   arg2 = (Dali::Quaternion *)jarg2;
11469   if (!arg2) {
11470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11471     return 0;
11472   }
11473   {
11474     try {
11475       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11476     } catch (std::out_of_range& e) {
11477       {
11478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11479       };
11480     } catch (std::exception& e) {
11481       {
11482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11483       };
11484     } catch (Dali::DaliException e) {
11485       {
11486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11487       };
11488     } catch (...) {
11489       {
11490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11491       };
11492     }
11493   }
11494
11495   jresult = (void *)result;
11496   return jresult;
11497 }
11498
11499
11500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11501   void * jresult ;
11502   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11503   float arg2 ;
11504   Dali::Quaternion *result = 0 ;
11505
11506   arg1 = (Dali::Quaternion *)jarg1;
11507   arg2 = (float)jarg2;
11508   {
11509     try {
11510       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11511     } catch (std::out_of_range& e) {
11512       {
11513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11514       };
11515     } catch (std::exception& e) {
11516       {
11517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11518       };
11519     } catch (Dali::DaliException e) {
11520       {
11521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11522       };
11523     } catch (...) {
11524       {
11525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11526       };
11527     }
11528   }
11529
11530   jresult = (void *)result;
11531   return jresult;
11532 }
11533
11534
11535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11536   void * jresult ;
11537   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11538   float arg2 ;
11539   Dali::Quaternion *result = 0 ;
11540
11541   arg1 = (Dali::Quaternion *)jarg1;
11542   arg2 = (float)jarg2;
11543   {
11544     try {
11545       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11546     } catch (std::out_of_range& e) {
11547       {
11548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11549       };
11550     } catch (std::exception& e) {
11551       {
11552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11553       };
11554     } catch (Dali::DaliException e) {
11555       {
11556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11557       };
11558     } catch (...) {
11559       {
11560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11561       };
11562     }
11563   }
11564
11565   jresult = (void *)result;
11566   return jresult;
11567 }
11568
11569
11570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11571   unsigned int jresult ;
11572   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11573   Dali::Quaternion *arg2 = 0 ;
11574   bool result;
11575
11576   arg1 = (Dali::Quaternion *)jarg1;
11577   arg2 = (Dali::Quaternion *)jarg2;
11578   if (!arg2) {
11579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11580     return 0;
11581   }
11582   {
11583     try {
11584       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11585     } catch (std::out_of_range& e) {
11586       {
11587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11588       };
11589     } catch (std::exception& e) {
11590       {
11591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11592       };
11593     } catch (Dali::DaliException e) {
11594       {
11595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11596       };
11597     } catch (...) {
11598       {
11599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11600       };
11601     }
11602   }
11603
11604   jresult = result;
11605   return jresult;
11606 }
11607
11608
11609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11610   unsigned int jresult ;
11611   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11612   Dali::Quaternion *arg2 = 0 ;
11613   bool result;
11614
11615   arg1 = (Dali::Quaternion *)jarg1;
11616   arg2 = (Dali::Quaternion *)jarg2;
11617   if (!arg2) {
11618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11619     return 0;
11620   }
11621   {
11622     try {
11623       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11624     } catch (std::out_of_range& e) {
11625       {
11626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11627       };
11628     } catch (std::exception& e) {
11629       {
11630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11631       };
11632     } catch (Dali::DaliException e) {
11633       {
11634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11635       };
11636     } catch (...) {
11637       {
11638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11639       };
11640     }
11641   }
11642
11643   jresult = result;
11644   return jresult;
11645 }
11646
11647
11648 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11649   float jresult ;
11650   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11651   float result;
11652
11653   arg1 = (Dali::Quaternion *)jarg1;
11654   {
11655     try {
11656       result = (float)((Dali::Quaternion const *)arg1)->Length();
11657     } catch (std::out_of_range& e) {
11658       {
11659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11660       };
11661     } catch (std::exception& e) {
11662       {
11663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11664       };
11665     } catch (Dali::DaliException e) {
11666       {
11667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11668       };
11669     } catch (...) {
11670       {
11671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11672       };
11673     }
11674   }
11675
11676   jresult = result;
11677   return jresult;
11678 }
11679
11680
11681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11682   float jresult ;
11683   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11684   float result;
11685
11686   arg1 = (Dali::Quaternion *)jarg1;
11687   {
11688     try {
11689       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11690     } catch (std::out_of_range& e) {
11691       {
11692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11693       };
11694     } catch (std::exception& e) {
11695       {
11696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11697       };
11698     } catch (Dali::DaliException e) {
11699       {
11700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11701       };
11702     } catch (...) {
11703       {
11704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11705       };
11706     }
11707   }
11708
11709   jresult = result;
11710   return jresult;
11711 }
11712
11713
11714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11715   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11716
11717   arg1 = (Dali::Quaternion *)jarg1;
11718   {
11719     try {
11720       (arg1)->Normalize();
11721     } catch (std::out_of_range& e) {
11722       {
11723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11724       };
11725     } catch (std::exception& e) {
11726       {
11727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11728       };
11729     } catch (Dali::DaliException e) {
11730       {
11731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11732       };
11733     } catch (...) {
11734       {
11735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11736       };
11737     }
11738   }
11739
11740 }
11741
11742
11743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11744   void * jresult ;
11745   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11746   Dali::Quaternion result;
11747
11748   arg1 = (Dali::Quaternion *)jarg1;
11749   {
11750     try {
11751       result = ((Dali::Quaternion const *)arg1)->Normalized();
11752     } catch (std::out_of_range& e) {
11753       {
11754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11755       };
11756     } catch (std::exception& e) {
11757       {
11758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11759       };
11760     } catch (Dali::DaliException e) {
11761       {
11762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11763       };
11764     } catch (...) {
11765       {
11766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11767       };
11768     }
11769   }
11770
11771   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11772   return jresult;
11773 }
11774
11775
11776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11777   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11778
11779   arg1 = (Dali::Quaternion *)jarg1;
11780   {
11781     try {
11782       (arg1)->Conjugate();
11783     } catch (std::out_of_range& e) {
11784       {
11785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11786       };
11787     } catch (std::exception& e) {
11788       {
11789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11790       };
11791     } catch (Dali::DaliException e) {
11792       {
11793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11794       };
11795     } catch (...) {
11796       {
11797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11798       };
11799     }
11800   }
11801
11802 }
11803
11804
11805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11806   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11807
11808   arg1 = (Dali::Quaternion *)jarg1;
11809   {
11810     try {
11811       (arg1)->Invert();
11812     } catch (std::out_of_range& e) {
11813       {
11814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11815       };
11816     } catch (std::exception& e) {
11817       {
11818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11819       };
11820     } catch (Dali::DaliException e) {
11821       {
11822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11823       };
11824     } catch (...) {
11825       {
11826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11827       };
11828     }
11829   }
11830
11831 }
11832
11833
11834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11835   void * jresult ;
11836   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11837   Dali::Quaternion result;
11838
11839   arg1 = (Dali::Quaternion *)jarg1;
11840   {
11841     try {
11842       result = ((Dali::Quaternion const *)arg1)->Log();
11843     } catch (std::out_of_range& e) {
11844       {
11845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11846       };
11847     } catch (std::exception& e) {
11848       {
11849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11850       };
11851     } catch (Dali::DaliException e) {
11852       {
11853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11854       };
11855     } catch (...) {
11856       {
11857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11858       };
11859     }
11860   }
11861
11862   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11863   return jresult;
11864 }
11865
11866
11867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11868   void * jresult ;
11869   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11870   Dali::Quaternion result;
11871
11872   arg1 = (Dali::Quaternion *)jarg1;
11873   {
11874     try {
11875       result = ((Dali::Quaternion const *)arg1)->Exp();
11876     } catch (std::out_of_range& e) {
11877       {
11878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11879       };
11880     } catch (std::exception& e) {
11881       {
11882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11883       };
11884     } catch (Dali::DaliException e) {
11885       {
11886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11887       };
11888     } catch (...) {
11889       {
11890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11891       };
11892     }
11893   }
11894
11895   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11896   return jresult;
11897 }
11898
11899
11900 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11901   float jresult ;
11902   Dali::Quaternion *arg1 = 0 ;
11903   Dali::Quaternion *arg2 = 0 ;
11904   float result;
11905
11906   arg1 = (Dali::Quaternion *)jarg1;
11907   if (!arg1) {
11908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11909     return 0;
11910   }
11911   arg2 = (Dali::Quaternion *)jarg2;
11912   if (!arg2) {
11913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11914     return 0;
11915   }
11916   {
11917     try {
11918       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11919     } catch (std::out_of_range& e) {
11920       {
11921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11922       };
11923     } catch (std::exception& e) {
11924       {
11925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11926       };
11927     } catch (Dali::DaliException e) {
11928       {
11929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11930       };
11931     } catch (...) {
11932       {
11933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11934       };
11935     }
11936   }
11937
11938   jresult = result;
11939   return jresult;
11940 }
11941
11942
11943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11944   void * jresult ;
11945   Dali::Quaternion *arg1 = 0 ;
11946   Dali::Quaternion *arg2 = 0 ;
11947   float arg3 ;
11948   Dali::Quaternion result;
11949
11950   arg1 = (Dali::Quaternion *)jarg1;
11951   if (!arg1) {
11952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11953     return 0;
11954   }
11955   arg2 = (Dali::Quaternion *)jarg2;
11956   if (!arg2) {
11957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11958     return 0;
11959   }
11960   arg3 = (float)jarg3;
11961   {
11962     try {
11963       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11964     } catch (std::out_of_range& e) {
11965       {
11966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11967       };
11968     } catch (std::exception& e) {
11969       {
11970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11971       };
11972     } catch (Dali::DaliException e) {
11973       {
11974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11975       };
11976     } catch (...) {
11977       {
11978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11979       };
11980     }
11981   }
11982
11983   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11984   return jresult;
11985 }
11986
11987
11988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11989   void * jresult ;
11990   Dali::Quaternion *arg1 = 0 ;
11991   Dali::Quaternion *arg2 = 0 ;
11992   float arg3 ;
11993   Dali::Quaternion result;
11994
11995   arg1 = (Dali::Quaternion *)jarg1;
11996   if (!arg1) {
11997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11998     return 0;
11999   }
12000   arg2 = (Dali::Quaternion *)jarg2;
12001   if (!arg2) {
12002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12003     return 0;
12004   }
12005   arg3 = (float)jarg3;
12006   {
12007     try {
12008       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12009     } catch (std::out_of_range& e) {
12010       {
12011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12012       };
12013     } catch (std::exception& e) {
12014       {
12015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12016       };
12017     } catch (Dali::DaliException e) {
12018       {
12019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12020       };
12021     } catch (...) {
12022       {
12023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12024       };
12025     }
12026   }
12027
12028   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12029   return jresult;
12030 }
12031
12032
12033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12034   void * jresult ;
12035   Dali::Quaternion *arg1 = 0 ;
12036   Dali::Quaternion *arg2 = 0 ;
12037   float arg3 ;
12038   Dali::Quaternion result;
12039
12040   arg1 = (Dali::Quaternion *)jarg1;
12041   if (!arg1) {
12042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12043     return 0;
12044   }
12045   arg2 = (Dali::Quaternion *)jarg2;
12046   if (!arg2) {
12047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12048     return 0;
12049   }
12050   arg3 = (float)jarg3;
12051   {
12052     try {
12053       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12054     } catch (std::out_of_range& e) {
12055       {
12056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12057       };
12058     } catch (std::exception& e) {
12059       {
12060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12061       };
12062     } catch (Dali::DaliException e) {
12063       {
12064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12065       };
12066     } catch (...) {
12067       {
12068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12069       };
12070     }
12071   }
12072
12073   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12074   return jresult;
12075 }
12076
12077
12078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12079   void * jresult ;
12080   Dali::Quaternion *arg1 = 0 ;
12081   Dali::Quaternion *arg2 = 0 ;
12082   Dali::Quaternion *arg3 = 0 ;
12083   Dali::Quaternion *arg4 = 0 ;
12084   float arg5 ;
12085   Dali::Quaternion result;
12086
12087   arg1 = (Dali::Quaternion *)jarg1;
12088   if (!arg1) {
12089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12090     return 0;
12091   }
12092   arg2 = (Dali::Quaternion *)jarg2;
12093   if (!arg2) {
12094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12095     return 0;
12096   }
12097   arg3 = (Dali::Quaternion *)jarg3;
12098   if (!arg3) {
12099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12100     return 0;
12101   }
12102   arg4 = (Dali::Quaternion *)jarg4;
12103   if (!arg4) {
12104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12105     return 0;
12106   }
12107   arg5 = (float)jarg5;
12108   {
12109     try {
12110       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12111     } catch (std::out_of_range& e) {
12112       {
12113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12114       };
12115     } catch (std::exception& e) {
12116       {
12117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12118       };
12119     } catch (Dali::DaliException e) {
12120       {
12121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12122       };
12123     } catch (...) {
12124       {
12125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12126       };
12127     }
12128   }
12129
12130   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12131   return jresult;
12132 }
12133
12134
12135 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12136   float jresult ;
12137   Dali::Quaternion *arg1 = 0 ;
12138   Dali::Quaternion *arg2 = 0 ;
12139   float result;
12140
12141   arg1 = (Dali::Quaternion *)jarg1;
12142   if (!arg1) {
12143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12144     return 0;
12145   }
12146   arg2 = (Dali::Quaternion *)jarg2;
12147   if (!arg2) {
12148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12149     return 0;
12150   }
12151   {
12152     try {
12153       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12154     } catch (std::out_of_range& e) {
12155       {
12156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12157       };
12158     } catch (std::exception& e) {
12159       {
12160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12161       };
12162     } catch (Dali::DaliException e) {
12163       {
12164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12165       };
12166     } catch (...) {
12167       {
12168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12169       };
12170     }
12171   }
12172
12173   jresult = result;
12174   return jresult;
12175 }
12176
12177
12178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12179   void * jresult ;
12180   Dali::Matrix *result = 0 ;
12181
12182   {
12183     try {
12184       result = (Dali::Matrix *)new Dali::Matrix();
12185     } catch (std::out_of_range& e) {
12186       {
12187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12188       };
12189     } catch (std::exception& e) {
12190       {
12191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12192       };
12193     } catch (Dali::DaliException e) {
12194       {
12195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12196       };
12197     } catch (...) {
12198       {
12199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12200       };
12201     }
12202   }
12203
12204   jresult = (void *)result;
12205   return jresult;
12206 }
12207
12208
12209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12210   void * jresult ;
12211   bool arg1 ;
12212   Dali::Matrix *result = 0 ;
12213
12214   arg1 = jarg1 ? true : false;
12215   {
12216     try {
12217       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12218     } catch (std::out_of_range& e) {
12219       {
12220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12221       };
12222     } catch (std::exception& e) {
12223       {
12224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12225       };
12226     } catch (Dali::DaliException e) {
12227       {
12228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12229       };
12230     } catch (...) {
12231       {
12232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12233       };
12234     }
12235   }
12236
12237   jresult = (void *)result;
12238   return jresult;
12239 }
12240
12241
12242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12243   void * jresult ;
12244   float *arg1 = (float *) 0 ;
12245   Dali::Matrix *result = 0 ;
12246
12247   arg1 = jarg1;
12248   {
12249     try {
12250       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12251     } catch (std::out_of_range& e) {
12252       {
12253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12254       };
12255     } catch (std::exception& e) {
12256       {
12257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12258       };
12259     } catch (Dali::DaliException e) {
12260       {
12261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12262       };
12263     } catch (...) {
12264       {
12265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12266       };
12267     }
12268   }
12269
12270   jresult = (void *)result;
12271
12272
12273   return jresult;
12274 }
12275
12276
12277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12278   void * jresult ;
12279   Dali::Quaternion *arg1 = 0 ;
12280   Dali::Matrix *result = 0 ;
12281
12282   arg1 = (Dali::Quaternion *)jarg1;
12283   if (!arg1) {
12284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12285     return 0;
12286   }
12287   {
12288     try {
12289       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12290     } catch (std::out_of_range& e) {
12291       {
12292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12293       };
12294     } catch (std::exception& e) {
12295       {
12296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12297       };
12298     } catch (Dali::DaliException e) {
12299       {
12300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12301       };
12302     } catch (...) {
12303       {
12304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12305       };
12306     }
12307   }
12308
12309   jresult = (void *)result;
12310   return jresult;
12311 }
12312
12313
12314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12315   void * jresult ;
12316   Dali::Matrix *arg1 = 0 ;
12317   Dali::Matrix *result = 0 ;
12318
12319   arg1 = (Dali::Matrix *)jarg1;
12320   if (!arg1) {
12321     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12322     return 0;
12323   }
12324   {
12325     try {
12326       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12327     } catch (std::out_of_range& e) {
12328       {
12329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12330       };
12331     } catch (std::exception& e) {
12332       {
12333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12334       };
12335     } catch (Dali::DaliException e) {
12336       {
12337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12338       };
12339     } catch (...) {
12340       {
12341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12342       };
12343     }
12344   }
12345
12346   jresult = (void *)result;
12347   return jresult;
12348 }
12349
12350
12351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12352   void * jresult ;
12353   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12354   Dali::Matrix *arg2 = 0 ;
12355   Dali::Matrix *result = 0 ;
12356
12357   arg1 = (Dali::Matrix *)jarg1;
12358   arg2 = (Dali::Matrix *)jarg2;
12359   if (!arg2) {
12360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12361     return 0;
12362   }
12363   {
12364     try {
12365       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12366     } catch (std::out_of_range& e) {
12367       {
12368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12369       };
12370     } catch (std::exception& e) {
12371       {
12372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12373       };
12374     } catch (Dali::DaliException e) {
12375       {
12376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12377       };
12378     } catch (...) {
12379       {
12380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12381       };
12382     }
12383   }
12384
12385   jresult = (void *)result;
12386   return jresult;
12387 }
12388
12389
12390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12391   void * jresult ;
12392   Dali::Matrix *result = 0 ;
12393
12394   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12395   jresult = (void *)result;
12396   return jresult;
12397 }
12398
12399
12400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12401   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12402
12403   arg1 = (Dali::Matrix *)jarg1;
12404   {
12405     try {
12406       (arg1)->SetIdentity();
12407     } catch (std::out_of_range& e) {
12408       {
12409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12410       };
12411     } catch (std::exception& e) {
12412       {
12413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12414       };
12415     } catch (Dali::DaliException e) {
12416       {
12417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12418       };
12419     } catch (...) {
12420       {
12421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12422       };
12423     }
12424   }
12425
12426 }
12427
12428
12429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12430   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12431   Dali::Vector3 *arg2 = 0 ;
12432
12433   arg1 = (Dali::Matrix *)jarg1;
12434   arg2 = (Dali::Vector3 *)jarg2;
12435   if (!arg2) {
12436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12437     return ;
12438   }
12439   {
12440     try {
12441       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12442     } catch (std::out_of_range& e) {
12443       {
12444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12445       };
12446     } catch (std::exception& e) {
12447       {
12448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12449       };
12450     } catch (Dali::DaliException e) {
12451       {
12452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12453       };
12454     } catch (...) {
12455       {
12456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12457       };
12458     }
12459   }
12460
12461 }
12462
12463
12464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12465   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12466   Dali::Matrix *arg2 = 0 ;
12467
12468   arg1 = (Dali::Matrix *)jarg1;
12469   arg2 = (Dali::Matrix *)jarg2;
12470   if (!arg2) {
12471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12472     return ;
12473   }
12474   {
12475     try {
12476       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12477     } catch (std::out_of_range& e) {
12478       {
12479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12480       };
12481     } catch (std::exception& e) {
12482       {
12483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12484       };
12485     } catch (Dali::DaliException e) {
12486       {
12487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12488       };
12489     } catch (...) {
12490       {
12491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12492       };
12493     }
12494   }
12495
12496 }
12497
12498
12499 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12500   unsigned int jresult ;
12501   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12502   bool result;
12503
12504   arg1 = (Dali::Matrix *)jarg1;
12505   {
12506     try {
12507       result = (bool)(arg1)->Invert();
12508     } catch (std::out_of_range& e) {
12509       {
12510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12511       };
12512     } catch (std::exception& e) {
12513       {
12514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12515       };
12516     } catch (Dali::DaliException e) {
12517       {
12518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12519       };
12520     } catch (...) {
12521       {
12522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12523       };
12524     }
12525   }
12526
12527   jresult = result;
12528   return jresult;
12529 }
12530
12531
12532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12533   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12534
12535   arg1 = (Dali::Matrix *)jarg1;
12536   {
12537     try {
12538       (arg1)->Transpose();
12539     } catch (std::out_of_range& e) {
12540       {
12541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12542       };
12543     } catch (std::exception& e) {
12544       {
12545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12546       };
12547     } catch (Dali::DaliException e) {
12548       {
12549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12550       };
12551     } catch (...) {
12552       {
12553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12554       };
12555     }
12556   }
12557
12558 }
12559
12560
12561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12562   void * jresult ;
12563   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12564   Dali::Vector3 result;
12565
12566   arg1 = (Dali::Matrix *)jarg1;
12567   {
12568     try {
12569       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12570     } catch (std::out_of_range& e) {
12571       {
12572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12573       };
12574     } catch (std::exception& e) {
12575       {
12576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12577       };
12578     } catch (Dali::DaliException e) {
12579       {
12580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12581       };
12582     } catch (...) {
12583       {
12584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12585       };
12586     }
12587   }
12588
12589   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12590   return jresult;
12591 }
12592
12593
12594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12595   void * jresult ;
12596   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12597   Dali::Vector3 result;
12598
12599   arg1 = (Dali::Matrix *)jarg1;
12600   {
12601     try {
12602       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12603     } catch (std::out_of_range& e) {
12604       {
12605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12606       };
12607     } catch (std::exception& e) {
12608       {
12609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12610       };
12611     } catch (Dali::DaliException e) {
12612       {
12613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12614       };
12615     } catch (...) {
12616       {
12617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12618       };
12619     }
12620   }
12621
12622   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12623   return jresult;
12624 }
12625
12626
12627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12628   void * jresult ;
12629   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12630   Dali::Vector3 result;
12631
12632   arg1 = (Dali::Matrix *)jarg1;
12633   {
12634     try {
12635       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12636     } catch (std::out_of_range& e) {
12637       {
12638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12639       };
12640     } catch (std::exception& e) {
12641       {
12642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12643       };
12644     } catch (Dali::DaliException e) {
12645       {
12646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12647       };
12648     } catch (...) {
12649       {
12650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12651       };
12652     }
12653   }
12654
12655   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12656   return jresult;
12657 }
12658
12659
12660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12661   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12662   Dali::Vector3 *arg2 = 0 ;
12663
12664   arg1 = (Dali::Matrix *)jarg1;
12665   arg2 = (Dali::Vector3 *)jarg2;
12666   if (!arg2) {
12667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12668     return ;
12669   }
12670   {
12671     try {
12672       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12673     } catch (std::out_of_range& e) {
12674       {
12675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12676       };
12677     } catch (std::exception& e) {
12678       {
12679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12680       };
12681     } catch (Dali::DaliException e) {
12682       {
12683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12684       };
12685     } catch (...) {
12686       {
12687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12688       };
12689     }
12690   }
12691
12692 }
12693
12694
12695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12696   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12697   Dali::Vector3 *arg2 = 0 ;
12698
12699   arg1 = (Dali::Matrix *)jarg1;
12700   arg2 = (Dali::Vector3 *)jarg2;
12701   if (!arg2) {
12702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12703     return ;
12704   }
12705   {
12706     try {
12707       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12708     } catch (std::out_of_range& e) {
12709       {
12710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12711       };
12712     } catch (std::exception& e) {
12713       {
12714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12715       };
12716     } catch (Dali::DaliException e) {
12717       {
12718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12719       };
12720     } catch (...) {
12721       {
12722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12723       };
12724     }
12725   }
12726
12727 }
12728
12729
12730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12731   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12732   Dali::Vector3 *arg2 = 0 ;
12733
12734   arg1 = (Dali::Matrix *)jarg1;
12735   arg2 = (Dali::Vector3 *)jarg2;
12736   if (!arg2) {
12737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12738     return ;
12739   }
12740   {
12741     try {
12742       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12743     } catch (std::out_of_range& e) {
12744       {
12745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12746       };
12747     } catch (std::exception& e) {
12748       {
12749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12750       };
12751     } catch (Dali::DaliException e) {
12752       {
12753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12754       };
12755     } catch (...) {
12756       {
12757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12758       };
12759     }
12760   }
12761
12762 }
12763
12764
12765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12766   void * jresult ;
12767   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12768   Dali::Vector4 *result = 0 ;
12769
12770   arg1 = (Dali::Matrix *)jarg1;
12771   {
12772     try {
12773       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12774     } catch (std::out_of_range& e) {
12775       {
12776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12777       };
12778     } catch (std::exception& e) {
12779       {
12780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12781       };
12782     } catch (Dali::DaliException e) {
12783       {
12784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12785       };
12786     } catch (...) {
12787       {
12788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12789       };
12790     }
12791   }
12792
12793   jresult = (void *)result;
12794   return jresult;
12795 }
12796
12797
12798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12799   void * jresult ;
12800   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12801   Dali::Vector3 *result = 0 ;
12802
12803   arg1 = (Dali::Matrix *)jarg1;
12804   {
12805     try {
12806       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12807     } catch (std::out_of_range& e) {
12808       {
12809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12810       };
12811     } catch (std::exception& e) {
12812       {
12813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12814       };
12815     } catch (Dali::DaliException e) {
12816       {
12817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12818       };
12819     } catch (...) {
12820       {
12821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12822       };
12823     }
12824   }
12825
12826   jresult = (void *)result;
12827   return jresult;
12828 }
12829
12830
12831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12832   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12833   Dali::Vector4 *arg2 = 0 ;
12834
12835   arg1 = (Dali::Matrix *)jarg1;
12836   arg2 = (Dali::Vector4 *)jarg2;
12837   if (!arg2) {
12838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12839     return ;
12840   }
12841   {
12842     try {
12843       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12844     } catch (std::out_of_range& e) {
12845       {
12846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12847       };
12848     } catch (std::exception& e) {
12849       {
12850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12851       };
12852     } catch (Dali::DaliException e) {
12853       {
12854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12855       };
12856     } catch (...) {
12857       {
12858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12859       };
12860     }
12861   }
12862
12863 }
12864
12865
12866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12867   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12868   Dali::Vector3 *arg2 = 0 ;
12869
12870   arg1 = (Dali::Matrix *)jarg1;
12871   arg2 = (Dali::Vector3 *)jarg2;
12872   if (!arg2) {
12873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12874     return ;
12875   }
12876   {
12877     try {
12878       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12879     } catch (std::out_of_range& e) {
12880       {
12881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12882       };
12883     } catch (std::exception& e) {
12884       {
12885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12886       };
12887     } catch (Dali::DaliException e) {
12888       {
12889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12890       };
12891     } catch (...) {
12892       {
12893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12894       };
12895     }
12896   }
12897
12898 }
12899
12900
12901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12902   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12903
12904   arg1 = (Dali::Matrix *)jarg1;
12905   {
12906     try {
12907       (arg1)->OrthoNormalize();
12908     } catch (std::out_of_range& e) {
12909       {
12910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12911       };
12912     } catch (std::exception& e) {
12913       {
12914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12915       };
12916     } catch (Dali::DaliException e) {
12917       {
12918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12919       };
12920     } catch (...) {
12921       {
12922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12923       };
12924     }
12925   }
12926
12927 }
12928
12929
12930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12931   void * jresult ;
12932   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12933   float *result = 0 ;
12934
12935   arg1 = (Dali::Matrix *)jarg1;
12936   {
12937     try {
12938       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12939     } catch (std::out_of_range& e) {
12940       {
12941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12942       };
12943     } catch (std::exception& e) {
12944       {
12945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12946       };
12947     } catch (Dali::DaliException e) {
12948       {
12949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12950       };
12951     } catch (...) {
12952       {
12953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12954       };
12955     }
12956   }
12957
12958   jresult = (void *)result;
12959   return jresult;
12960 }
12961
12962
12963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12964   Dali::Matrix *arg1 = 0 ;
12965   Dali::Matrix *arg2 = 0 ;
12966   Dali::Matrix *arg3 = 0 ;
12967
12968   arg1 = (Dali::Matrix *)jarg1;
12969   if (!arg1) {
12970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12971     return ;
12972   }
12973   arg2 = (Dali::Matrix *)jarg2;
12974   if (!arg2) {
12975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12976     return ;
12977   }
12978   arg3 = (Dali::Matrix *)jarg3;
12979   if (!arg3) {
12980     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12981     return ;
12982   }
12983   {
12984     try {
12985       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12986     } catch (std::out_of_range& e) {
12987       {
12988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12989       };
12990     } catch (std::exception& e) {
12991       {
12992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12993       };
12994     } catch (Dali::DaliException e) {
12995       {
12996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12997       };
12998     } catch (...) {
12999       {
13000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13001       };
13002     }
13003   }
13004
13005 }
13006
13007
13008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13009   Dali::Matrix *arg1 = 0 ;
13010   Dali::Matrix *arg2 = 0 ;
13011   Dali::Quaternion *arg3 = 0 ;
13012
13013   arg1 = (Dali::Matrix *)jarg1;
13014   if (!arg1) {
13015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13016     return ;
13017   }
13018   arg2 = (Dali::Matrix *)jarg2;
13019   if (!arg2) {
13020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13021     return ;
13022   }
13023   arg3 = (Dali::Quaternion *)jarg3;
13024   if (!arg3) {
13025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13026     return ;
13027   }
13028   {
13029     try {
13030       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13031     } catch (std::out_of_range& e) {
13032       {
13033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13034       };
13035     } catch (std::exception& e) {
13036       {
13037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13038       };
13039     } catch (Dali::DaliException e) {
13040       {
13041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13042       };
13043     } catch (...) {
13044       {
13045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13046       };
13047     }
13048   }
13049
13050 }
13051
13052
13053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13054   void * jresult ;
13055   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13056   Dali::Vector4 *arg2 = 0 ;
13057   Dali::Vector4 result;
13058
13059   arg1 = (Dali::Matrix *)jarg1;
13060   arg2 = (Dali::Vector4 *)jarg2;
13061   if (!arg2) {
13062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13063     return 0;
13064   }
13065   {
13066     try {
13067       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13068     } catch (std::out_of_range& e) {
13069       {
13070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13071       };
13072     } catch (std::exception& e) {
13073       {
13074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13075       };
13076     } catch (Dali::DaliException e) {
13077       {
13078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13079       };
13080     } catch (...) {
13081       {
13082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13083       };
13084     }
13085   }
13086
13087   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13088   return jresult;
13089 }
13090
13091
13092 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13093   unsigned int jresult ;
13094   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13095   Dali::Matrix *arg2 = 0 ;
13096   bool result;
13097
13098   arg1 = (Dali::Matrix *)jarg1;
13099   arg2 = (Dali::Matrix *)jarg2;
13100   if (!arg2) {
13101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13102     return 0;
13103   }
13104   {
13105     try {
13106       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13107     } catch (std::out_of_range& e) {
13108       {
13109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13110       };
13111     } catch (std::exception& e) {
13112       {
13113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13114       };
13115     } catch (Dali::DaliException e) {
13116       {
13117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13118       };
13119     } catch (...) {
13120       {
13121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13122       };
13123     }
13124   }
13125
13126   jresult = result;
13127   return jresult;
13128 }
13129
13130
13131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13132   unsigned int jresult ;
13133   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13134   Dali::Matrix *arg2 = 0 ;
13135   bool result;
13136
13137   arg1 = (Dali::Matrix *)jarg1;
13138   arg2 = (Dali::Matrix *)jarg2;
13139   if (!arg2) {
13140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13141     return 0;
13142   }
13143   {
13144     try {
13145       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13146     } catch (std::out_of_range& e) {
13147       {
13148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13149       };
13150     } catch (std::exception& e) {
13151       {
13152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13153       };
13154     } catch (Dali::DaliException e) {
13155       {
13156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13157       };
13158     } catch (...) {
13159       {
13160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13161       };
13162     }
13163   }
13164
13165   jresult = result;
13166   return jresult;
13167 }
13168
13169
13170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13171   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13172   Dali::Vector3 *arg2 = 0 ;
13173   Dali::Quaternion *arg3 = 0 ;
13174   Dali::Vector3 *arg4 = 0 ;
13175
13176   arg1 = (Dali::Matrix *)jarg1;
13177   arg2 = (Dali::Vector3 *)jarg2;
13178   if (!arg2) {
13179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13180     return ;
13181   }
13182   arg3 = (Dali::Quaternion *)jarg3;
13183   if (!arg3) {
13184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13185     return ;
13186   }
13187   arg4 = (Dali::Vector3 *)jarg4;
13188   if (!arg4) {
13189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13190     return ;
13191   }
13192   {
13193     try {
13194       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13195     } catch (std::out_of_range& e) {
13196       {
13197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13198       };
13199     } catch (std::exception& e) {
13200       {
13201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13202       };
13203     } catch (Dali::DaliException e) {
13204       {
13205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13206       };
13207     } catch (...) {
13208       {
13209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13210       };
13211     }
13212   }
13213
13214 }
13215
13216
13217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13218   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13219   Dali::Vector3 *arg2 = 0 ;
13220   Dali::Quaternion *arg3 = 0 ;
13221   Dali::Vector3 *arg4 = 0 ;
13222
13223   arg1 = (Dali::Matrix *)jarg1;
13224   arg2 = (Dali::Vector3 *)jarg2;
13225   if (!arg2) {
13226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13227     return ;
13228   }
13229   arg3 = (Dali::Quaternion *)jarg3;
13230   if (!arg3) {
13231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13232     return ;
13233   }
13234   arg4 = (Dali::Vector3 *)jarg4;
13235   if (!arg4) {
13236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13237     return ;
13238   }
13239   {
13240     try {
13241       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13242     } catch (std::out_of_range& e) {
13243       {
13244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13245       };
13246     } catch (std::exception& e) {
13247       {
13248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13249       };
13250     } catch (Dali::DaliException e) {
13251       {
13252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13253       };
13254     } catch (...) {
13255       {
13256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13257       };
13258     }
13259   }
13260
13261 }
13262
13263
13264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13265   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13266   Dali::Vector3 *arg2 = 0 ;
13267   Dali::Vector3 *arg3 = 0 ;
13268   Dali::Vector3 *arg4 = 0 ;
13269   Dali::Vector3 *arg5 = 0 ;
13270
13271   arg1 = (Dali::Matrix *)jarg1;
13272   arg2 = (Dali::Vector3 *)jarg2;
13273   if (!arg2) {
13274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13275     return ;
13276   }
13277   arg3 = (Dali::Vector3 *)jarg3;
13278   if (!arg3) {
13279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13280     return ;
13281   }
13282   arg4 = (Dali::Vector3 *)jarg4;
13283   if (!arg4) {
13284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13285     return ;
13286   }
13287   arg5 = (Dali::Vector3 *)jarg5;
13288   if (!arg5) {
13289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13290     return ;
13291   }
13292   {
13293     try {
13294       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13295     } catch (std::out_of_range& e) {
13296       {
13297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13298       };
13299     } catch (std::exception& e) {
13300       {
13301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13302       };
13303     } catch (Dali::DaliException e) {
13304       {
13305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13306       };
13307     } catch (...) {
13308       {
13309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13310       };
13311     }
13312   }
13313
13314 }
13315
13316
13317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13318   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13319   Dali::Vector3 *arg2 = 0 ;
13320   Dali::Quaternion *arg3 = 0 ;
13321   Dali::Vector3 *arg4 = 0 ;
13322
13323   arg1 = (Dali::Matrix *)jarg1;
13324   arg2 = (Dali::Vector3 *)jarg2;
13325   if (!arg2) {
13326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13327     return ;
13328   }
13329   arg3 = (Dali::Quaternion *)jarg3;
13330   if (!arg3) {
13331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13332     return ;
13333   }
13334   arg4 = (Dali::Vector3 *)jarg4;
13335   if (!arg4) {
13336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13337     return ;
13338   }
13339   {
13340     try {
13341       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13342     } catch (std::out_of_range& e) {
13343       {
13344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13345       };
13346     } catch (std::exception& e) {
13347       {
13348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13349       };
13350     } catch (Dali::DaliException e) {
13351       {
13352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13353       };
13354     } catch (...) {
13355       {
13356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13357       };
13358     }
13359   }
13360
13361 }
13362
13363
13364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13365   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13366
13367   arg1 = (Dali::Matrix *)jarg1;
13368   {
13369     try {
13370       delete arg1;
13371     } catch (std::out_of_range& e) {
13372       {
13373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13374       };
13375     } catch (std::exception& e) {
13376       {
13377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13378       };
13379     } catch (Dali::DaliException e) {
13380       {
13381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13382       };
13383     } catch (...) {
13384       {
13385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13386       };
13387     }
13388   }
13389
13390 }
13391
13392
13393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13394   void * jresult ;
13395   Dali::Matrix3 *result = 0 ;
13396
13397   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13398   jresult = (void *)result;
13399   return jresult;
13400 }
13401
13402
13403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13404   void * jresult ;
13405   Dali::Matrix3 *result = 0 ;
13406
13407   {
13408     try {
13409       result = (Dali::Matrix3 *)new Dali::Matrix3();
13410     } catch (std::out_of_range& e) {
13411       {
13412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13413       };
13414     } catch (std::exception& e) {
13415       {
13416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13417       };
13418     } catch (Dali::DaliException e) {
13419       {
13420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13421       };
13422     } catch (...) {
13423       {
13424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13425       };
13426     }
13427   }
13428
13429   jresult = (void *)result;
13430   return jresult;
13431 }
13432
13433
13434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13435   void * jresult ;
13436   Dali::Matrix3 *arg1 = 0 ;
13437   Dali::Matrix3 *result = 0 ;
13438
13439   arg1 = (Dali::Matrix3 *)jarg1;
13440   if (!arg1) {
13441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13442     return 0;
13443   }
13444   {
13445     try {
13446       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13447     } catch (std::out_of_range& e) {
13448       {
13449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13450       };
13451     } catch (std::exception& e) {
13452       {
13453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13454       };
13455     } catch (Dali::DaliException e) {
13456       {
13457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13458       };
13459     } catch (...) {
13460       {
13461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13462       };
13463     }
13464   }
13465
13466   jresult = (void *)result;
13467   return jresult;
13468 }
13469
13470
13471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13472   void * jresult ;
13473   Dali::Matrix *arg1 = 0 ;
13474   Dali::Matrix3 *result = 0 ;
13475
13476   arg1 = (Dali::Matrix *)jarg1;
13477   if (!arg1) {
13478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13479     return 0;
13480   }
13481   {
13482     try {
13483       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13484     } catch (std::out_of_range& e) {
13485       {
13486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13487       };
13488     } catch (std::exception& e) {
13489       {
13490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13491       };
13492     } catch (Dali::DaliException e) {
13493       {
13494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13495       };
13496     } catch (...) {
13497       {
13498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13499       };
13500     }
13501   }
13502
13503   jresult = (void *)result;
13504   return jresult;
13505 }
13506
13507
13508 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) {
13509   void * jresult ;
13510   float arg1 ;
13511   float arg2 ;
13512   float arg3 ;
13513   float arg4 ;
13514   float arg5 ;
13515   float arg6 ;
13516   float arg7 ;
13517   float arg8 ;
13518   float arg9 ;
13519   Dali::Matrix3 *result = 0 ;
13520
13521   arg1 = (float)jarg1;
13522   arg2 = (float)jarg2;
13523   arg3 = (float)jarg3;
13524   arg4 = (float)jarg4;
13525   arg5 = (float)jarg5;
13526   arg6 = (float)jarg6;
13527   arg7 = (float)jarg7;
13528   arg8 = (float)jarg8;
13529   arg9 = (float)jarg9;
13530   {
13531     try {
13532       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13533     } catch (std::out_of_range& e) {
13534       {
13535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13536       };
13537     } catch (std::exception& e) {
13538       {
13539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13540       };
13541     } catch (Dali::DaliException e) {
13542       {
13543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13544       };
13545     } catch (...) {
13546       {
13547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13548       };
13549     }
13550   }
13551
13552   jresult = (void *)result;
13553   return jresult;
13554 }
13555
13556
13557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13558   void * jresult ;
13559   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13560   Dali::Matrix3 *arg2 = 0 ;
13561   Dali::Matrix3 *result = 0 ;
13562
13563   arg1 = (Dali::Matrix3 *)jarg1;
13564   arg2 = (Dali::Matrix3 *)jarg2;
13565   if (!arg2) {
13566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13567     return 0;
13568   }
13569   {
13570     try {
13571       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13572     } catch (std::out_of_range& e) {
13573       {
13574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13575       };
13576     } catch (std::exception& e) {
13577       {
13578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13579       };
13580     } catch (Dali::DaliException e) {
13581       {
13582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13583       };
13584     } catch (...) {
13585       {
13586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13587       };
13588     }
13589   }
13590
13591   jresult = (void *)result;
13592   return jresult;
13593 }
13594
13595
13596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13597   void * jresult ;
13598   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13599   Dali::Matrix *arg2 = 0 ;
13600   Dali::Matrix3 *result = 0 ;
13601
13602   arg1 = (Dali::Matrix3 *)jarg1;
13603   arg2 = (Dali::Matrix *)jarg2;
13604   if (!arg2) {
13605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13606     return 0;
13607   }
13608   {
13609     try {
13610       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13611     } catch (std::out_of_range& e) {
13612       {
13613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13614       };
13615     } catch (std::exception& e) {
13616       {
13617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13618       };
13619     } catch (Dali::DaliException e) {
13620       {
13621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13622       };
13623     } catch (...) {
13624       {
13625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13626       };
13627     }
13628   }
13629
13630   jresult = (void *)result;
13631   return jresult;
13632 }
13633
13634
13635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13636   unsigned int jresult ;
13637   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13638   Dali::Matrix3 *arg2 = 0 ;
13639   bool result;
13640
13641   arg1 = (Dali::Matrix3 *)jarg1;
13642   arg2 = (Dali::Matrix3 *)jarg2;
13643   if (!arg2) {
13644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13645     return 0;
13646   }
13647   {
13648     try {
13649       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13650     } catch (std::out_of_range& e) {
13651       {
13652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13653       };
13654     } catch (std::exception& e) {
13655       {
13656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13657       };
13658     } catch (Dali::DaliException e) {
13659       {
13660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13661       };
13662     } catch (...) {
13663       {
13664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13665       };
13666     }
13667   }
13668
13669   jresult = result;
13670   return jresult;
13671 }
13672
13673
13674 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13675   unsigned int jresult ;
13676   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13677   Dali::Matrix3 *arg2 = 0 ;
13678   bool result;
13679
13680   arg1 = (Dali::Matrix3 *)jarg1;
13681   arg2 = (Dali::Matrix3 *)jarg2;
13682   if (!arg2) {
13683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13684     return 0;
13685   }
13686   {
13687     try {
13688       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13689     } catch (std::out_of_range& e) {
13690       {
13691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13692       };
13693     } catch (std::exception& e) {
13694       {
13695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13696       };
13697     } catch (Dali::DaliException e) {
13698       {
13699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13700       };
13701     } catch (...) {
13702       {
13703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13704       };
13705     }
13706   }
13707
13708   jresult = result;
13709   return jresult;
13710 }
13711
13712
13713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13714   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13715
13716   arg1 = (Dali::Matrix3 *)jarg1;
13717   {
13718     try {
13719       delete arg1;
13720     } catch (std::out_of_range& e) {
13721       {
13722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13723       };
13724     } catch (std::exception& e) {
13725       {
13726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13727       };
13728     } catch (Dali::DaliException e) {
13729       {
13730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13731       };
13732     } catch (...) {
13733       {
13734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13735       };
13736     }
13737   }
13738
13739 }
13740
13741
13742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13743   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13744
13745   arg1 = (Dali::Matrix3 *)jarg1;
13746   {
13747     try {
13748       (arg1)->SetIdentity();
13749     } catch (std::out_of_range& e) {
13750       {
13751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13752       };
13753     } catch (std::exception& e) {
13754       {
13755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13756       };
13757     } catch (Dali::DaliException e) {
13758       {
13759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13760       };
13761     } catch (...) {
13762       {
13763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13764       };
13765     }
13766   }
13767
13768 }
13769
13770
13771 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13772   void * jresult ;
13773   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13774   float *result = 0 ;
13775
13776   arg1 = (Dali::Matrix3 *)jarg1;
13777   {
13778     try {
13779       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13780     } catch (std::out_of_range& e) {
13781       {
13782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13783       };
13784     } catch (std::exception& e) {
13785       {
13786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13787       };
13788     } catch (Dali::DaliException e) {
13789       {
13790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13791       };
13792     } catch (...) {
13793       {
13794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13795       };
13796     }
13797   }
13798
13799   jresult = (void *)result;
13800   return jresult;
13801 }
13802
13803
13804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13805   unsigned int jresult ;
13806   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13807   bool result;
13808
13809   arg1 = (Dali::Matrix3 *)jarg1;
13810   {
13811     try {
13812       result = (bool)(arg1)->Invert();
13813     } catch (std::out_of_range& e) {
13814       {
13815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13816       };
13817     } catch (std::exception& e) {
13818       {
13819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13820       };
13821     } catch (Dali::DaliException e) {
13822       {
13823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13824       };
13825     } catch (...) {
13826       {
13827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13828       };
13829     }
13830   }
13831
13832   jresult = result;
13833   return jresult;
13834 }
13835
13836
13837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13838   unsigned int jresult ;
13839   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13840   bool result;
13841
13842   arg1 = (Dali::Matrix3 *)jarg1;
13843   {
13844     try {
13845       result = (bool)(arg1)->Transpose();
13846     } catch (std::out_of_range& e) {
13847       {
13848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13849       };
13850     } catch (std::exception& e) {
13851       {
13852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13853       };
13854     } catch (Dali::DaliException e) {
13855       {
13856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13857       };
13858     } catch (...) {
13859       {
13860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13861       };
13862     }
13863   }
13864
13865   jresult = result;
13866   return jresult;
13867 }
13868
13869
13870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13871   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13872   float arg2 ;
13873
13874   arg1 = (Dali::Matrix3 *)jarg1;
13875   arg2 = (float)jarg2;
13876   {
13877     try {
13878       (arg1)->Scale(arg2);
13879     } catch (std::out_of_range& e) {
13880       {
13881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13882       };
13883     } catch (std::exception& e) {
13884       {
13885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13886       };
13887     } catch (Dali::DaliException e) {
13888       {
13889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13890       };
13891     } catch (...) {
13892       {
13893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13894       };
13895     }
13896   }
13897
13898 }
13899
13900
13901 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13902   float jresult ;
13903   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13904   float result;
13905
13906   arg1 = (Dali::Matrix3 *)jarg1;
13907   {
13908     try {
13909       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13910     } catch (std::out_of_range& e) {
13911       {
13912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13913       };
13914     } catch (std::exception& e) {
13915       {
13916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13917       };
13918     } catch (Dali::DaliException e) {
13919       {
13920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13921       };
13922     } catch (...) {
13923       {
13924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13925       };
13926     }
13927   }
13928
13929   jresult = result;
13930   return jresult;
13931 }
13932
13933
13934 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13935   unsigned int jresult ;
13936   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13937   bool result;
13938
13939   arg1 = (Dali::Matrix3 *)jarg1;
13940   {
13941     try {
13942       result = (bool)(arg1)->ScaledInverseTranspose();
13943     } catch (std::out_of_range& e) {
13944       {
13945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13946       };
13947     } catch (std::exception& e) {
13948       {
13949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13950       };
13951     } catch (Dali::DaliException e) {
13952       {
13953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13954       };
13955     } catch (...) {
13956       {
13957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13958       };
13959     }
13960   }
13961
13962   jresult = result;
13963   return jresult;
13964 }
13965
13966
13967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13968   Dali::Matrix3 *arg1 = 0 ;
13969   Dali::Matrix3 *arg2 = 0 ;
13970   Dali::Matrix3 *arg3 = 0 ;
13971
13972   arg1 = (Dali::Matrix3 *)jarg1;
13973   if (!arg1) {
13974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13975     return ;
13976   }
13977   arg2 = (Dali::Matrix3 *)jarg2;
13978   if (!arg2) {
13979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13980     return ;
13981   }
13982   arg3 = (Dali::Matrix3 *)jarg3;
13983   if (!arg3) {
13984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13985     return ;
13986   }
13987   {
13988     try {
13989       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13990     } catch (std::out_of_range& e) {
13991       {
13992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13993       };
13994     } catch (std::exception& e) {
13995       {
13996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13997       };
13998     } catch (Dali::DaliException e) {
13999       {
14000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14001       };
14002     } catch (...) {
14003       {
14004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14005       };
14006     }
14007   }
14008
14009 }
14010
14011
14012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14013   float jresult ;
14014   float arg1 ;
14015   float arg2 ;
14016   float result;
14017
14018   arg1 = (float)jarg1;
14019   arg2 = (float)jarg2;
14020   {
14021     try {
14022       result = (float)Dali::Random::Range(arg1,arg2);
14023     } catch (std::out_of_range& e) {
14024       {
14025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14026       };
14027     } catch (std::exception& e) {
14028       {
14029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14030       };
14031     } catch (Dali::DaliException e) {
14032       {
14033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14034       };
14035     } catch (...) {
14036       {
14037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14038       };
14039     }
14040   }
14041
14042   jresult = result;
14043   return jresult;
14044 }
14045
14046
14047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14048   void * jresult ;
14049   Dali::Vector4 result;
14050
14051   {
14052     try {
14053       result = Dali::Random::Axis();
14054     } catch (std::out_of_range& e) {
14055       {
14056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14057       };
14058     } catch (std::exception& e) {
14059       {
14060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14061       };
14062     } catch (Dali::DaliException e) {
14063       {
14064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14065       };
14066     } catch (...) {
14067       {
14068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14069       };
14070     }
14071   }
14072
14073   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14074   return jresult;
14075 }
14076
14077
14078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14079   void * jresult ;
14080   Dali::AngleAxis *result = 0 ;
14081
14082   {
14083     try {
14084       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14085     } catch (std::out_of_range& e) {
14086       {
14087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14088       };
14089     } catch (std::exception& e) {
14090       {
14091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14092       };
14093     } catch (Dali::DaliException e) {
14094       {
14095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14096       };
14097     } catch (...) {
14098       {
14099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14100       };
14101     }
14102   }
14103
14104   jresult = (void *)result;
14105   return jresult;
14106 }
14107
14108
14109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14110   void * jresult ;
14111   Dali::Radian arg1 ;
14112   Dali::Vector3 *arg2 = 0 ;
14113   Dali::Radian *argp1 ;
14114   Dali::AngleAxis *result = 0 ;
14115
14116   argp1 = (Dali::Radian *)jarg1;
14117   if (!argp1) {
14118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14119     return 0;
14120   }
14121   arg1 = *argp1;
14122   arg2 = (Dali::Vector3 *)jarg2;
14123   if (!arg2) {
14124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14125     return 0;
14126   }
14127   {
14128     try {
14129       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14130     } catch (std::out_of_range& e) {
14131       {
14132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14133       };
14134     } catch (std::exception& e) {
14135       {
14136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14137       };
14138     } catch (Dali::DaliException e) {
14139       {
14140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14141       };
14142     } catch (...) {
14143       {
14144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14145       };
14146     }
14147   }
14148
14149   jresult = (void *)result;
14150   return jresult;
14151 }
14152
14153
14154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14155   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14156   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14157
14158   arg1 = (Dali::AngleAxis *)jarg1;
14159   arg2 = (Dali::Radian *)jarg2;
14160   if (arg1) (arg1)->angle = *arg2;
14161 }
14162
14163
14164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14165   void * jresult ;
14166   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14167   Dali::Radian *result = 0 ;
14168
14169   arg1 = (Dali::AngleAxis *)jarg1;
14170   result = (Dali::Radian *)& ((arg1)->angle);
14171   jresult = (void *)result;
14172   return jresult;
14173 }
14174
14175
14176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14177   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14178   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14179
14180   arg1 = (Dali::AngleAxis *)jarg1;
14181   arg2 = (Dali::Vector3 *)jarg2;
14182   if (arg1) (arg1)->axis = *arg2;
14183 }
14184
14185
14186 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14187   void * jresult ;
14188   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14189   Dali::Vector3 *result = 0 ;
14190
14191   arg1 = (Dali::AngleAxis *)jarg1;
14192   result = (Dali::Vector3 *)& ((arg1)->axis);
14193   jresult = (void *)result;
14194   return jresult;
14195 }
14196
14197
14198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14199   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14200
14201   arg1 = (Dali::AngleAxis *)jarg1;
14202   {
14203     try {
14204       delete arg1;
14205     } catch (std::out_of_range& e) {
14206       {
14207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14208       };
14209     } catch (std::exception& e) {
14210       {
14211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14212       };
14213     } catch (Dali::DaliException e) {
14214       {
14215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14216       };
14217     } catch (...) {
14218       {
14219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14220       };
14221     }
14222   }
14223
14224 }
14225
14226
14227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14228   unsigned int jresult ;
14229   Dali::AngleAxis *arg1 = 0 ;
14230   Dali::AngleAxis *arg2 = 0 ;
14231   bool result;
14232
14233   arg1 = (Dali::AngleAxis *)jarg1;
14234   if (!arg1) {
14235     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14236     return 0;
14237   }
14238   arg2 = (Dali::AngleAxis *)jarg2;
14239   if (!arg2) {
14240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14241     return 0;
14242   }
14243   {
14244     try {
14245       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14246     } catch (std::out_of_range& e) {
14247       {
14248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14249       };
14250     } catch (std::exception& e) {
14251       {
14252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14253       };
14254     } catch (Dali::DaliException e) {
14255       {
14256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14257       };
14258     } catch (...) {
14259       {
14260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14261       };
14262     }
14263   }
14264
14265   jresult = result;
14266   return jresult;
14267 }
14268
14269
14270 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14271   unsigned int jresult ;
14272   unsigned int arg1 ;
14273   unsigned int result;
14274
14275   arg1 = (unsigned int)jarg1;
14276   {
14277     try {
14278       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14279     } catch (std::out_of_range& e) {
14280       {
14281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14282       };
14283     } catch (std::exception& e) {
14284       {
14285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14286       };
14287     } catch (Dali::DaliException e) {
14288       {
14289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14290       };
14291     } catch (...) {
14292       {
14293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14294       };
14295     }
14296   }
14297
14298   jresult = result;
14299   return jresult;
14300 }
14301
14302
14303 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14304   unsigned int jresult ;
14305   unsigned int arg1 ;
14306   bool result;
14307
14308   arg1 = (unsigned int)jarg1;
14309   {
14310     try {
14311       result = (bool)Dali::IsPowerOfTwo(arg1);
14312     } catch (std::out_of_range& e) {
14313       {
14314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14315       };
14316     } catch (std::exception& e) {
14317       {
14318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14319       };
14320     } catch (Dali::DaliException e) {
14321       {
14322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14323       };
14324     } catch (...) {
14325       {
14326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14327       };
14328     }
14329   }
14330
14331   jresult = result;
14332   return jresult;
14333 }
14334
14335
14336 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14337   float jresult ;
14338   float arg1 ;
14339   float arg2 ;
14340   float result;
14341
14342   arg1 = (float)jarg1;
14343   arg2 = (float)jarg2;
14344   {
14345     try {
14346       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14347     } catch (std::out_of_range& e) {
14348       {
14349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14350       };
14351     } catch (std::exception& e) {
14352       {
14353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14354       };
14355     } catch (Dali::DaliException e) {
14356       {
14357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14358       };
14359     } catch (...) {
14360       {
14361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14362       };
14363     }
14364   }
14365
14366   jresult = result;
14367   return jresult;
14368 }
14369
14370
14371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14372   unsigned int jresult ;
14373   float arg1 ;
14374   bool result;
14375
14376   arg1 = (float)jarg1;
14377   {
14378     try {
14379       result = (bool)Dali::EqualsZero(arg1);
14380     } catch (std::out_of_range& e) {
14381       {
14382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14383       };
14384     } catch (std::exception& e) {
14385       {
14386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14387       };
14388     } catch (Dali::DaliException e) {
14389       {
14390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14391       };
14392     } catch (...) {
14393       {
14394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14395       };
14396     }
14397   }
14398
14399   jresult = result;
14400   return jresult;
14401 }
14402
14403
14404 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14405   unsigned int jresult ;
14406   float arg1 ;
14407   float arg2 ;
14408   bool result;
14409
14410   arg1 = (float)jarg1;
14411   arg2 = (float)jarg2;
14412   {
14413     try {
14414       result = (bool)Dali::Equals(arg1,arg2);
14415     } catch (std::out_of_range& e) {
14416       {
14417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14418       };
14419     } catch (std::exception& e) {
14420       {
14421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14422       };
14423     } catch (Dali::DaliException e) {
14424       {
14425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14426       };
14427     } catch (...) {
14428       {
14429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14430       };
14431     }
14432   }
14433
14434   jresult = result;
14435   return jresult;
14436 }
14437
14438
14439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14440   unsigned int jresult ;
14441   float arg1 ;
14442   float arg2 ;
14443   float arg3 ;
14444   bool result;
14445
14446   arg1 = (float)jarg1;
14447   arg2 = (float)jarg2;
14448   arg3 = (float)jarg3;
14449   {
14450     try {
14451       result = (bool)Dali::Equals(arg1,arg2,arg3);
14452     } catch (std::out_of_range& e) {
14453       {
14454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14455       };
14456     } catch (std::exception& e) {
14457       {
14458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14459       };
14460     } catch (Dali::DaliException e) {
14461       {
14462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14463       };
14464     } catch (...) {
14465       {
14466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14467       };
14468     }
14469   }
14470
14471   jresult = result;
14472   return jresult;
14473 }
14474
14475
14476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14477   float jresult ;
14478   float arg1 ;
14479   int arg2 ;
14480   float result;
14481
14482   arg1 = (float)jarg1;
14483   arg2 = (int)jarg2;
14484   {
14485     try {
14486       result = (float)Dali::Round(arg1,arg2);
14487     } catch (std::out_of_range& e) {
14488       {
14489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14490       };
14491     } catch (std::exception& e) {
14492       {
14493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14494       };
14495     } catch (Dali::DaliException e) {
14496       {
14497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14498       };
14499     } catch (...) {
14500       {
14501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14502       };
14503     }
14504   }
14505
14506   jresult = result;
14507   return jresult;
14508 }
14509
14510
14511 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14512   float jresult ;
14513   float arg1 ;
14514   float arg2 ;
14515   float arg3 ;
14516   float result;
14517
14518   arg1 = (float)jarg1;
14519   arg2 = (float)jarg2;
14520   arg3 = (float)jarg3;
14521   {
14522     try {
14523       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14524     } catch (std::out_of_range& e) {
14525       {
14526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14527       };
14528     } catch (std::exception& e) {
14529       {
14530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14531       };
14532     } catch (Dali::DaliException e) {
14533       {
14534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14535       };
14536     } catch (...) {
14537       {
14538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14539       };
14540     }
14541   }
14542
14543   jresult = result;
14544   return jresult;
14545 }
14546
14547
14548 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14549   float jresult ;
14550   float arg1 ;
14551   float arg2 ;
14552   float arg3 ;
14553   float arg4 ;
14554   float result;
14555
14556   arg1 = (float)jarg1;
14557   arg2 = (float)jarg2;
14558   arg3 = (float)jarg3;
14559   arg4 = (float)jarg4;
14560   {
14561     try {
14562       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14563     } catch (std::out_of_range& e) {
14564       {
14565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14566       };
14567     } catch (std::exception& e) {
14568       {
14569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14570       };
14571     } catch (Dali::DaliException e) {
14572       {
14573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14574       };
14575     } catch (...) {
14576       {
14577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14578       };
14579     }
14580   }
14581
14582   jresult = result;
14583   return jresult;
14584 }
14585
14586
14587 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14588   int jresult ;
14589   int result;
14590
14591   result = (int)(int)Dali::Property::INVALID_INDEX;
14592   jresult = result;
14593   return jresult;
14594 }
14595
14596
14597 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14598   int jresult ;
14599   int result;
14600
14601   result = (int)(int)Dali::Property::INVALID_KEY;
14602   jresult = result;
14603   return jresult;
14604 }
14605
14606
14607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14608   int jresult ;
14609   int result;
14610
14611   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14612   jresult = result;
14613   return jresult;
14614 }
14615
14616
14617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14618   void * jresult ;
14619   Dali::Handle *arg1 = 0 ;
14620   Dali::Property::Index arg2 ;
14621   Dali::Property *result = 0 ;
14622
14623   arg1 = (Dali::Handle *)jarg1;
14624   if (!arg1) {
14625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14626     return 0;
14627   }
14628   arg2 = (Dali::Property::Index)jarg2;
14629   {
14630     try {
14631       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14632     } catch (std::out_of_range& e) {
14633       {
14634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14635       };
14636     } catch (std::exception& e) {
14637       {
14638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14639       };
14640     } catch (Dali::DaliException e) {
14641       {
14642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14643       };
14644     } catch (...) {
14645       {
14646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14647       };
14648     }
14649   }
14650
14651   jresult = (void *)result;
14652   return jresult;
14653 }
14654
14655
14656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14657   void * jresult ;
14658   Dali::Handle *arg1 = 0 ;
14659   Dali::Property::Index arg2 ;
14660   int arg3 ;
14661   Dali::Property *result = 0 ;
14662
14663   arg1 = (Dali::Handle *)jarg1;
14664   if (!arg1) {
14665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14666     return 0;
14667   }
14668   arg2 = (Dali::Property::Index)jarg2;
14669   arg3 = (int)jarg3;
14670   {
14671     try {
14672       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14673     } catch (std::out_of_range& e) {
14674       {
14675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14676       };
14677     } catch (std::exception& e) {
14678       {
14679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14680       };
14681     } catch (Dali::DaliException e) {
14682       {
14683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14684       };
14685     } catch (...) {
14686       {
14687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14688       };
14689     }
14690   }
14691
14692   jresult = (void *)result;
14693   return jresult;
14694 }
14695
14696
14697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14698   void * jresult ;
14699   Dali::Handle *arg1 = 0 ;
14700   std::string *arg2 = 0 ;
14701   Dali::Property *result = 0 ;
14702
14703   arg1 = (Dali::Handle *)jarg1;
14704   if (!arg1) {
14705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14706     return 0;
14707   }
14708   if (!jarg2) {
14709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14710     return 0;
14711   }
14712   std::string arg2_str(jarg2);
14713   arg2 = &arg2_str;
14714   {
14715     try {
14716       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14717     } catch (std::out_of_range& e) {
14718       {
14719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14720       };
14721     } catch (std::exception& e) {
14722       {
14723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14724       };
14725     } catch (Dali::DaliException e) {
14726       {
14727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14728       };
14729     } catch (...) {
14730       {
14731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14732       };
14733     }
14734   }
14735
14736   jresult = (void *)result;
14737
14738   //argout typemap for const std::string&
14739
14740   return jresult;
14741 }
14742
14743
14744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14745   void * jresult ;
14746   Dali::Handle *arg1 = 0 ;
14747   std::string *arg2 = 0 ;
14748   int arg3 ;
14749   Dali::Property *result = 0 ;
14750
14751   arg1 = (Dali::Handle *)jarg1;
14752   if (!arg1) {
14753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14754     return 0;
14755   }
14756   if (!jarg2) {
14757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14758     return 0;
14759   }
14760   std::string arg2_str(jarg2);
14761   arg2 = &arg2_str;
14762   arg3 = (int)jarg3;
14763   {
14764     try {
14765       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14766     } catch (std::out_of_range& e) {
14767       {
14768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14769       };
14770     } catch (std::exception& e) {
14771       {
14772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14773       };
14774     } catch (Dali::DaliException e) {
14775       {
14776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14777       };
14778     } catch (...) {
14779       {
14780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14781       };
14782     }
14783   }
14784
14785   jresult = (void *)result;
14786
14787   //argout typemap for const std::string&
14788
14789   return jresult;
14790 }
14791
14792
14793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14794   Dali::Property *arg1 = (Dali::Property *) 0 ;
14795
14796   arg1 = (Dali::Property *)jarg1;
14797   {
14798     try {
14799       delete arg1;
14800     } catch (std::out_of_range& e) {
14801       {
14802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14803       };
14804     } catch (std::exception& e) {
14805       {
14806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14807       };
14808     } catch (Dali::DaliException e) {
14809       {
14810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14811       };
14812     } catch (...) {
14813       {
14814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14815       };
14816     }
14817   }
14818
14819 }
14820
14821
14822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14823   Dali::Property *arg1 = (Dali::Property *) 0 ;
14824   Dali::Handle *arg2 = 0 ;
14825
14826   arg1 = (Dali::Property *)jarg1;
14827   arg2 = (Dali::Handle *)jarg2;
14828   if (!arg2) {
14829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14830     return ;
14831   }
14832   if (arg1) (arg1)->object = *arg2;
14833 }
14834
14835
14836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14837   void * jresult ;
14838   Dali::Property *arg1 = (Dali::Property *) 0 ;
14839   Dali::Handle *result = 0 ;
14840
14841   arg1 = (Dali::Property *)jarg1;
14842   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14843   jresult = (void *)result;
14844   return jresult;
14845 }
14846
14847
14848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14849   Dali::Property *arg1 = (Dali::Property *) 0 ;
14850   Dali::Property::Index arg2 ;
14851
14852   arg1 = (Dali::Property *)jarg1;
14853   arg2 = (Dali::Property::Index)jarg2;
14854   if (arg1) (arg1)->propertyIndex = arg2;
14855 }
14856
14857
14858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14859   int jresult ;
14860   Dali::Property *arg1 = (Dali::Property *) 0 ;
14861   Dali::Property::Index result;
14862
14863   arg1 = (Dali::Property *)jarg1;
14864   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14865   jresult = result;
14866   return jresult;
14867 }
14868
14869
14870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14871   Dali::Property *arg1 = (Dali::Property *) 0 ;
14872   int arg2 ;
14873
14874   arg1 = (Dali::Property *)jarg1;
14875   arg2 = (int)jarg2;
14876   if (arg1) (arg1)->componentIndex = arg2;
14877 }
14878
14879
14880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14881   int jresult ;
14882   Dali::Property *arg1 = (Dali::Property *) 0 ;
14883   int result;
14884
14885   arg1 = (Dali::Property *)jarg1;
14886   result = (int) ((arg1)->componentIndex);
14887   jresult = result;
14888   return jresult;
14889 }
14890
14891
14892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14893   void * jresult ;
14894   Dali::Property::Array *result = 0 ;
14895
14896   {
14897     try {
14898       result = (Dali::Property::Array *)new Dali::Property::Array();
14899     } catch (std::out_of_range& e) {
14900       {
14901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14902       };
14903     } catch (std::exception& e) {
14904       {
14905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14906       };
14907     } catch (Dali::DaliException e) {
14908       {
14909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14910       };
14911     } catch (...) {
14912       {
14913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14914       };
14915     }
14916   }
14917
14918   jresult = (void *)result;
14919   return jresult;
14920 }
14921
14922
14923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14924   void * jresult ;
14925   Dali::Property::Array *arg1 = 0 ;
14926   Dali::Property::Array *result = 0 ;
14927
14928   arg1 = (Dali::Property::Array *)jarg1;
14929   if (!arg1) {
14930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14931     return 0;
14932   }
14933   {
14934     try {
14935       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14936     } catch (std::out_of_range& e) {
14937       {
14938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14939       };
14940     } catch (std::exception& e) {
14941       {
14942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14943       };
14944     } catch (Dali::DaliException e) {
14945       {
14946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14947       };
14948     } catch (...) {
14949       {
14950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14951       };
14952     }
14953   }
14954
14955   jresult = (void *)result;
14956   return jresult;
14957 }
14958
14959
14960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14961   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14962
14963   arg1 = (Dali::Property::Array *)jarg1;
14964   {
14965     try {
14966       delete arg1;
14967     } catch (std::out_of_range& e) {
14968       {
14969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14970       };
14971     } catch (std::exception& e) {
14972       {
14973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14974       };
14975     } catch (Dali::DaliException e) {
14976       {
14977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14978       };
14979     } catch (...) {
14980       {
14981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14982       };
14983     }
14984   }
14985
14986 }
14987
14988
14989 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14990   unsigned long jresult ;
14991   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14992   Dali::Property::Array::SizeType result;
14993
14994   arg1 = (Dali::Property::Array *)jarg1;
14995   {
14996     try {
14997       result = ((Dali::Property::Array const *)arg1)->Size();
14998     } catch (std::out_of_range& e) {
14999       {
15000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15001       };
15002     } catch (std::exception& e) {
15003       {
15004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15005       };
15006     } catch (Dali::DaliException e) {
15007       {
15008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15009       };
15010     } catch (...) {
15011       {
15012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15013       };
15014     }
15015   }
15016
15017   jresult = (unsigned long)result;
15018   return jresult;
15019 }
15020
15021
15022 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15023   unsigned long jresult ;
15024   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15025   Dali::Property::Array::SizeType result;
15026
15027   arg1 = (Dali::Property::Array *)jarg1;
15028   {
15029     try {
15030       result = ((Dali::Property::Array const *)arg1)->Count();
15031     } catch (std::out_of_range& e) {
15032       {
15033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15034       };
15035     } catch (std::exception& e) {
15036       {
15037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15038       };
15039     } catch (Dali::DaliException e) {
15040       {
15041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15042       };
15043     } catch (...) {
15044       {
15045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15046       };
15047     }
15048   }
15049
15050   jresult = (unsigned long)result;
15051   return jresult;
15052 }
15053
15054
15055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15056   unsigned int jresult ;
15057   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15058   bool result;
15059
15060   arg1 = (Dali::Property::Array *)jarg1;
15061   {
15062     try {
15063       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15064     } catch (std::out_of_range& e) {
15065       {
15066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15067       };
15068     } catch (std::exception& e) {
15069       {
15070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15071       };
15072     } catch (Dali::DaliException e) {
15073       {
15074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15075       };
15076     } catch (...) {
15077       {
15078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15079       };
15080     }
15081   }
15082
15083   jresult = result;
15084   return jresult;
15085 }
15086
15087
15088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15089   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15090
15091   arg1 = (Dali::Property::Array *)jarg1;
15092   {
15093     try {
15094       (arg1)->Clear();
15095     } catch (std::out_of_range& e) {
15096       {
15097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15098       };
15099     } catch (std::exception& e) {
15100       {
15101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15102       };
15103     } catch (Dali::DaliException e) {
15104       {
15105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15106       };
15107     } catch (...) {
15108       {
15109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15110       };
15111     }
15112   }
15113
15114 }
15115
15116
15117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15118   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15119   Dali::Property::Array::SizeType arg2 ;
15120
15121   arg1 = (Dali::Property::Array *)jarg1;
15122   arg2 = (Dali::Property::Array::SizeType)jarg2;
15123   {
15124     try {
15125       (arg1)->Reserve(arg2);
15126     } catch (std::out_of_range& e) {
15127       {
15128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15129       };
15130     } catch (std::exception& e) {
15131       {
15132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15133       };
15134     } catch (Dali::DaliException e) {
15135       {
15136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15137       };
15138     } catch (...) {
15139       {
15140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15141       };
15142     }
15143   }
15144
15145 }
15146
15147
15148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15149   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15150   Dali::Property::Array::SizeType arg2 ;
15151
15152   arg1 = (Dali::Property::Array *)jarg1;
15153   arg2 = (Dali::Property::Array::SizeType)jarg2;
15154   {
15155     try {
15156       (arg1)->Resize(arg2);
15157     } catch (std::out_of_range& e) {
15158       {
15159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15160       };
15161     } catch (std::exception& e) {
15162       {
15163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15164       };
15165     } catch (Dali::DaliException e) {
15166       {
15167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15168       };
15169     } catch (...) {
15170       {
15171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15172       };
15173     }
15174   }
15175
15176 }
15177
15178
15179 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15180   unsigned long jresult ;
15181   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15182   Dali::Property::Array::SizeType result;
15183
15184   arg1 = (Dali::Property::Array *)jarg1;
15185   {
15186     try {
15187       result = (arg1)->Capacity();
15188     } catch (std::out_of_range& e) {
15189       {
15190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15191       };
15192     } catch (std::exception& e) {
15193       {
15194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15195       };
15196     } catch (Dali::DaliException e) {
15197       {
15198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15199       };
15200     } catch (...) {
15201       {
15202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15203       };
15204     }
15205   }
15206
15207   jresult = (unsigned long)result;
15208   return jresult;
15209 }
15210
15211
15212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15213   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15214   Dali::Property::Value *arg2 = 0 ;
15215
15216   arg1 = (Dali::Property::Array *)jarg1;
15217   arg2 = (Dali::Property::Value *)jarg2;
15218   if (!arg2) {
15219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15220     return ;
15221   }
15222   {
15223     try {
15224       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15225     } catch (std::out_of_range& e) {
15226       {
15227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15228       };
15229     } catch (std::exception& e) {
15230       {
15231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15232       };
15233     } catch (Dali::DaliException e) {
15234       {
15235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15236       };
15237     } catch (...) {
15238       {
15239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15240       };
15241     }
15242   }
15243
15244 }
15245
15246
15247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15248   void * jresult ;
15249   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15250   Dali::Property::Value *arg2 = 0 ;
15251   Dali::Property::Array *result = 0 ;
15252
15253   arg1 = (Dali::Property::Array *)jarg1;
15254   arg2 = (Dali::Property::Value *)jarg2;
15255   if (!arg2) {
15256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15257     return 0;
15258   }
15259   {
15260     try {
15261       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15262     } catch (std::out_of_range& e) {
15263       {
15264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15265       };
15266     } catch (std::exception& e) {
15267       {
15268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15269       };
15270     } catch (Dali::DaliException e) {
15271       {
15272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15273       };
15274     } catch (...) {
15275       {
15276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15277       };
15278     }
15279   }
15280
15281   jresult = (void *)result;
15282   return jresult;
15283 }
15284
15285
15286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15287   void * jresult ;
15288   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15289   Dali::Property::Array::SizeType arg2 ;
15290   Dali::Property::Value *result = 0 ;
15291
15292   arg1 = (Dali::Property::Array *)jarg1;
15293   arg2 = (Dali::Property::Array::SizeType)jarg2;
15294   {
15295     try {
15296       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15297     } catch (std::out_of_range& e) {
15298       {
15299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15300       };
15301     } catch (std::exception& e) {
15302       {
15303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15304       };
15305     } catch (Dali::DaliException e) {
15306       {
15307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15308       };
15309     } catch (...) {
15310       {
15311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15312       };
15313     }
15314   }
15315
15316   jresult = (void *)result;
15317   return jresult;
15318 }
15319
15320
15321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15322   void * jresult ;
15323   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15324   Dali::Property::Array::SizeType arg2 ;
15325   Dali::Property::Value *result = 0 ;
15326
15327   arg1 = (Dali::Property::Array *)jarg1;
15328   arg2 = (Dali::Property::Array::SizeType)jarg2;
15329   {
15330     try {
15331       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15332     } catch (std::out_of_range& e) {
15333       {
15334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15335       };
15336     } catch (std::exception& e) {
15337       {
15338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15339       };
15340     } catch (Dali::DaliException e) {
15341       {
15342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15343       };
15344     } catch (...) {
15345       {
15346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15347       };
15348     }
15349   }
15350
15351   jresult = (void *)result;
15352   return jresult;
15353 }
15354
15355
15356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15357   void * jresult ;
15358   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15359   Dali::Property::Array *arg2 = 0 ;
15360   Dali::Property::Array *result = 0 ;
15361
15362   arg1 = (Dali::Property::Array *)jarg1;
15363   arg2 = (Dali::Property::Array *)jarg2;
15364   if (!arg2) {
15365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15366     return 0;
15367   }
15368   {
15369     try {
15370       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15371     } catch (std::out_of_range& e) {
15372       {
15373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15374       };
15375     } catch (std::exception& e) {
15376       {
15377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15378       };
15379     } catch (Dali::DaliException e) {
15380       {
15381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15382       };
15383     } catch (...) {
15384       {
15385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15386       };
15387     }
15388   }
15389
15390   jresult = (void *)result;
15391   return jresult;
15392 }
15393
15394
15395 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15396   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15397   enum Dali::Property::Key::Type arg2 ;
15398
15399   arg1 = (Dali::Property::Key *)jarg1;
15400   arg2 = (enum Dali::Property::Key::Type)jarg2;
15401   if (arg1) (arg1)->type = arg2;
15402 }
15403
15404
15405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15406   int jresult ;
15407   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15408   enum Dali::Property::Key::Type result;
15409
15410   arg1 = (Dali::Property::Key *)jarg1;
15411   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15412   jresult = (int)result;
15413   return jresult;
15414 }
15415
15416
15417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15418   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15419   Dali::Property::Index arg2 ;
15420
15421   arg1 = (Dali::Property::Key *)jarg1;
15422   arg2 = (Dali::Property::Index)jarg2;
15423   if (arg1) (arg1)->indexKey = arg2;
15424 }
15425
15426
15427 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15428   int jresult ;
15429   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15430   Dali::Property::Index result;
15431
15432   arg1 = (Dali::Property::Key *)jarg1;
15433   result = (Dali::Property::Index) ((arg1)->indexKey);
15434   jresult = result;
15435   return jresult;
15436 }
15437
15438
15439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15440   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15441   std::string *arg2 = 0 ;
15442
15443   arg1 = (Dali::Property::Key *)jarg1;
15444   if (!jarg2) {
15445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15446     return ;
15447   }
15448   std::string arg2_str(jarg2);
15449   arg2 = &arg2_str;
15450   if (arg1) (arg1)->stringKey = *arg2;
15451
15452   //argout typemap for const std::string&
15453
15454 }
15455
15456
15457 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15458   char * jresult ;
15459   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15460   std::string *result = 0 ;
15461
15462   arg1 = (Dali::Property::Key *)jarg1;
15463   result = (std::string *) & ((arg1)->stringKey);
15464   jresult = SWIG_csharp_string_callback(result->c_str());
15465   return jresult;
15466 }
15467
15468
15469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15470   void * jresult ;
15471   std::string *arg1 = 0 ;
15472   Dali::Property::Key *result = 0 ;
15473
15474   if (!jarg1) {
15475     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15476     return 0;
15477   }
15478   std::string arg1_str(jarg1);
15479   arg1 = &arg1_str;
15480   {
15481     try {
15482       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15483     } catch (std::out_of_range& e) {
15484       {
15485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15486       };
15487     } catch (std::exception& e) {
15488       {
15489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15490       };
15491     } catch (Dali::DaliException e) {
15492       {
15493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15494       };
15495     } catch (...) {
15496       {
15497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15498       };
15499     }
15500   }
15501
15502   jresult = (void *)result;
15503
15504   //argout typemap for const std::string&
15505
15506   return jresult;
15507 }
15508
15509
15510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15511   void * jresult ;
15512   Dali::Property::Index arg1 ;
15513   Dali::Property::Key *result = 0 ;
15514
15515   arg1 = (Dali::Property::Index)jarg1;
15516   {
15517     try {
15518       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15519     } catch (std::out_of_range& e) {
15520       {
15521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15522       };
15523     } catch (std::exception& e) {
15524       {
15525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15526       };
15527     } catch (Dali::DaliException e) {
15528       {
15529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15530       };
15531     } catch (...) {
15532       {
15533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15534       };
15535     }
15536   }
15537
15538   jresult = (void *)result;
15539   return jresult;
15540 }
15541
15542
15543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15544   unsigned int jresult ;
15545   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15546   std::string *arg2 = 0 ;
15547   bool result;
15548
15549   arg1 = (Dali::Property::Key *)jarg1;
15550   if (!jarg2) {
15551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15552     return 0;
15553   }
15554   std::string arg2_str(jarg2);
15555   arg2 = &arg2_str;
15556   {
15557     try {
15558       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15559     } catch (std::out_of_range& e) {
15560       {
15561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15562       };
15563     } catch (std::exception& e) {
15564       {
15565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15566       };
15567     } catch (Dali::DaliException e) {
15568       {
15569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15570       };
15571     } catch (...) {
15572       {
15573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15574       };
15575     }
15576   }
15577
15578   jresult = result;
15579
15580   //argout typemap for const std::string&
15581
15582   return jresult;
15583 }
15584
15585
15586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15587   unsigned int jresult ;
15588   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15589   Dali::Property::Index arg2 ;
15590   bool result;
15591
15592   arg1 = (Dali::Property::Key *)jarg1;
15593   arg2 = (Dali::Property::Index)jarg2;
15594   {
15595     try {
15596       result = (bool)(arg1)->operator ==(arg2);
15597     } catch (std::out_of_range& e) {
15598       {
15599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15600       };
15601     } catch (std::exception& e) {
15602       {
15603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15604       };
15605     } catch (Dali::DaliException e) {
15606       {
15607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15608       };
15609     } catch (...) {
15610       {
15611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15612       };
15613     }
15614   }
15615
15616   jresult = result;
15617   return jresult;
15618 }
15619
15620
15621 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15622   unsigned int jresult ;
15623   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15624   Dali::Property::Key *arg2 = 0 ;
15625   bool result;
15626
15627   arg1 = (Dali::Property::Key *)jarg1;
15628   arg2 = (Dali::Property::Key *)jarg2;
15629   if (!arg2) {
15630     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15631     return 0;
15632   }
15633   {
15634     try {
15635       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15636     } catch (std::out_of_range& e) {
15637       {
15638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15639       };
15640     } catch (std::exception& e) {
15641       {
15642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15643       };
15644     } catch (Dali::DaliException e) {
15645       {
15646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15647       };
15648     } catch (...) {
15649       {
15650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15651       };
15652     }
15653   }
15654
15655   jresult = result;
15656   return jresult;
15657 }
15658
15659
15660 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15661   unsigned int jresult ;
15662   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15663   std::string *arg2 = 0 ;
15664   bool result;
15665
15666   arg1 = (Dali::Property::Key *)jarg1;
15667   if (!jarg2) {
15668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15669     return 0;
15670   }
15671   std::string arg2_str(jarg2);
15672   arg2 = &arg2_str;
15673   {
15674     try {
15675       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15676     } catch (std::out_of_range& e) {
15677       {
15678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15679       };
15680     } catch (std::exception& e) {
15681       {
15682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15683       };
15684     } catch (Dali::DaliException e) {
15685       {
15686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15687       };
15688     } catch (...) {
15689       {
15690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15691       };
15692     }
15693   }
15694
15695   jresult = result;
15696
15697   //argout typemap for const std::string&
15698
15699   return jresult;
15700 }
15701
15702
15703 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15704   unsigned int jresult ;
15705   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15706   Dali::Property::Index arg2 ;
15707   bool result;
15708
15709   arg1 = (Dali::Property::Key *)jarg1;
15710   arg2 = (Dali::Property::Index)jarg2;
15711   {
15712     try {
15713       result = (bool)(arg1)->operator !=(arg2);
15714     } catch (std::out_of_range& e) {
15715       {
15716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15717       };
15718     } catch (std::exception& e) {
15719       {
15720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15721       };
15722     } catch (Dali::DaliException e) {
15723       {
15724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15725       };
15726     } catch (...) {
15727       {
15728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15729       };
15730     }
15731   }
15732
15733   jresult = result;
15734   return jresult;
15735 }
15736
15737
15738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15739   unsigned int jresult ;
15740   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15741   Dali::Property::Key *arg2 = 0 ;
15742   bool result;
15743
15744   arg1 = (Dali::Property::Key *)jarg1;
15745   arg2 = (Dali::Property::Key *)jarg2;
15746   if (!arg2) {
15747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15748     return 0;
15749   }
15750   {
15751     try {
15752       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15753     } catch (std::out_of_range& e) {
15754       {
15755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15756       };
15757     } catch (std::exception& e) {
15758       {
15759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15760       };
15761     } catch (Dali::DaliException e) {
15762       {
15763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15764       };
15765     } catch (...) {
15766       {
15767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15768       };
15769     }
15770   }
15771
15772   jresult = result;
15773   return jresult;
15774 }
15775
15776
15777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15778   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15779
15780   arg1 = (Dali::Property::Key *)jarg1;
15781   {
15782     try {
15783       delete arg1;
15784     } catch (std::out_of_range& e) {
15785       {
15786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15787       };
15788     } catch (std::exception& e) {
15789       {
15790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15791       };
15792     } catch (Dali::DaliException e) {
15793       {
15794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15795       };
15796     } catch (...) {
15797       {
15798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15799       };
15800     }
15801   }
15802
15803 }
15804
15805
15806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15807   void * jresult ;
15808   Dali::Property::Map *result = 0 ;
15809
15810   {
15811     try {
15812       result = (Dali::Property::Map *)new Dali::Property::Map();
15813     } catch (std::out_of_range& e) {
15814       {
15815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15816       };
15817     } catch (std::exception& e) {
15818       {
15819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15820       };
15821     } catch (Dali::DaliException e) {
15822       {
15823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15824       };
15825     } catch (...) {
15826       {
15827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15828       };
15829     }
15830   }
15831
15832   jresult = (void *)result;
15833   return jresult;
15834 }
15835
15836
15837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15838   void * jresult ;
15839   Dali::Property::Map *arg1 = 0 ;
15840   Dali::Property::Map *result = 0 ;
15841
15842   arg1 = (Dali::Property::Map *)jarg1;
15843   if (!arg1) {
15844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15845     return 0;
15846   }
15847   {
15848     try {
15849       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15850     } catch (std::out_of_range& e) {
15851       {
15852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15853       };
15854     } catch (std::exception& e) {
15855       {
15856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15857       };
15858     } catch (Dali::DaliException e) {
15859       {
15860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15861       };
15862     } catch (...) {
15863       {
15864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15865       };
15866     }
15867   }
15868
15869   jresult = (void *)result;
15870   return jresult;
15871 }
15872
15873
15874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15875   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15876
15877   arg1 = (Dali::Property::Map *)jarg1;
15878   {
15879     try {
15880       delete arg1;
15881     } catch (std::out_of_range& e) {
15882       {
15883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15884       };
15885     } catch (std::exception& e) {
15886       {
15887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15888       };
15889     } catch (Dali::DaliException e) {
15890       {
15891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15892       };
15893     } catch (...) {
15894       {
15895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15896       };
15897     }
15898   }
15899
15900 }
15901
15902
15903 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15904   unsigned long jresult ;
15905   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15906   Dali::Property::Map::SizeType result;
15907
15908   arg1 = (Dali::Property::Map *)jarg1;
15909   {
15910     try {
15911       result = ((Dali::Property::Map const *)arg1)->Count();
15912     } catch (std::out_of_range& e) {
15913       {
15914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15915       };
15916     } catch (std::exception& e) {
15917       {
15918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15919       };
15920     } catch (Dali::DaliException e) {
15921       {
15922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15923       };
15924     } catch (...) {
15925       {
15926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15927       };
15928     }
15929   }
15930
15931   jresult = (unsigned long)result;
15932   return jresult;
15933 }
15934
15935
15936 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15937   unsigned int jresult ;
15938   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15939   bool result;
15940
15941   arg1 = (Dali::Property::Map *)jarg1;
15942   {
15943     try {
15944       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15945     } catch (std::out_of_range& e) {
15946       {
15947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15948       };
15949     } catch (std::exception& e) {
15950       {
15951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15952       };
15953     } catch (Dali::DaliException e) {
15954       {
15955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15956       };
15957     } catch (...) {
15958       {
15959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15960       };
15961     }
15962   }
15963
15964   jresult = result;
15965   return jresult;
15966 }
15967
15968
15969 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15970   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15971   char *arg2 = (char *) 0 ;
15972   Dali::Property::Value *arg3 = 0 ;
15973
15974   arg1 = (Dali::Property::Map *)jarg1;
15975   arg2 = (char *)jarg2;
15976   arg3 = (Dali::Property::Value *)jarg3;
15977   if (!arg3) {
15978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15979     return ;
15980   }
15981   {
15982     try {
15983       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15984     } catch (std::out_of_range& e) {
15985       {
15986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15987       };
15988     } catch (std::exception& e) {
15989       {
15990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15991       };
15992     } catch (Dali::DaliException e) {
15993       {
15994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15995       };
15996     } catch (...) {
15997       {
15998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15999       };
16000     }
16001   }
16002
16003 }
16004
16005
16006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16007   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16008   Dali::Property::Index arg2 ;
16009   Dali::Property::Value *arg3 = 0 ;
16010
16011   arg1 = (Dali::Property::Map *)jarg1;
16012   arg2 = (Dali::Property::Index)jarg2;
16013   arg3 = (Dali::Property::Value *)jarg3;
16014   if (!arg3) {
16015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16016     return ;
16017   }
16018   {
16019     try {
16020       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16021     } catch (std::out_of_range& e) {
16022       {
16023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16024       };
16025     } catch (std::exception& e) {
16026       {
16027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16028       };
16029     } catch (Dali::DaliException e) {
16030       {
16031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16032       };
16033     } catch (...) {
16034       {
16035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16036       };
16037     }
16038   }
16039
16040 }
16041
16042
16043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16044   void * jresult ;
16045   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16046   char *arg2 = (char *) 0 ;
16047   Dali::Property::Value *arg3 = 0 ;
16048   Dali::Property::Map *result = 0 ;
16049
16050   arg1 = (Dali::Property::Map *)jarg1;
16051   arg2 = (char *)jarg2;
16052   arg3 = (Dali::Property::Value *)jarg3;
16053   if (!arg3) {
16054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16055     return 0;
16056   }
16057   {
16058     try {
16059       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16060     } catch (std::out_of_range& e) {
16061       {
16062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16063       };
16064     } catch (std::exception& e) {
16065       {
16066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16067       };
16068     } catch (Dali::DaliException e) {
16069       {
16070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16071       };
16072     } catch (...) {
16073       {
16074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16075       };
16076     }
16077   }
16078
16079   jresult = (void *)result;
16080   return jresult;
16081 }
16082
16083
16084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16085   void * jresult ;
16086   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16087   Dali::Property::Index arg2 ;
16088   Dali::Property::Value *arg3 = 0 ;
16089   Dali::Property::Map *result = 0 ;
16090
16091   arg1 = (Dali::Property::Map *)jarg1;
16092   arg2 = (Dali::Property::Index)jarg2;
16093   arg3 = (Dali::Property::Value *)jarg3;
16094   if (!arg3) {
16095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16096     return 0;
16097   }
16098   {
16099     try {
16100       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16101     } catch (std::out_of_range& e) {
16102       {
16103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16104       };
16105     } catch (std::exception& e) {
16106       {
16107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16108       };
16109     } catch (Dali::DaliException e) {
16110       {
16111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16112       };
16113     } catch (...) {
16114       {
16115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16116       };
16117     }
16118   }
16119
16120   jresult = (void *)result;
16121   return jresult;
16122 }
16123
16124
16125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16126   void * jresult ;
16127   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16128   Dali::Property::Map::SizeType arg2 ;
16129   Dali::Property::Value *result = 0 ;
16130
16131   arg1 = (Dali::Property::Map *)jarg1;
16132   arg2 = (Dali::Property::Map::SizeType)jarg2;
16133   {
16134     try {
16135       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16136     } catch (std::out_of_range& e) {
16137       {
16138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16139       };
16140     } catch (std::exception& e) {
16141       {
16142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16143       };
16144     } catch (Dali::DaliException e) {
16145       {
16146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16147       };
16148     } catch (...) {
16149       {
16150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16151       };
16152     }
16153   }
16154
16155   jresult = (void *)result;
16156   return jresult;
16157 }
16158
16159
16160 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16161   char * jresult ;
16162   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16163   Dali::Property::Map::SizeType arg2 ;
16164   std::string *result = 0 ;
16165
16166   arg1 = (Dali::Property::Map *)jarg1;
16167   arg2 = (Dali::Property::Map::SizeType)jarg2;
16168   {
16169     try {
16170       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16171     } catch (std::out_of_range& e) {
16172       {
16173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16174       };
16175     } catch (std::exception& e) {
16176       {
16177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16178       };
16179     } catch (Dali::DaliException e) {
16180       {
16181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16182       };
16183     } catch (...) {
16184       {
16185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16186       };
16187     }
16188   }
16189
16190   jresult = SWIG_csharp_string_callback(result->c_str());
16191   return jresult;
16192 }
16193
16194
16195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16196   void * jresult ;
16197   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16198   Dali::Property::Map::SizeType arg2 ;
16199   SwigValueWrapper< Dali::Property::Key > result;
16200
16201   arg1 = (Dali::Property::Map *)jarg1;
16202   arg2 = (Dali::Property::Map::SizeType)jarg2;
16203   {
16204     try {
16205       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16206     } catch (std::out_of_range& e) {
16207       {
16208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16209       };
16210     } catch (std::exception& e) {
16211       {
16212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16213       };
16214     } catch (Dali::DaliException e) {
16215       {
16216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16217       };
16218     } catch (...) {
16219       {
16220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16221       };
16222     }
16223   }
16224
16225   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16226   return jresult;
16227 }
16228
16229
16230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16231   void * jresult ;
16232   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16233   Dali::Property::Map::SizeType arg2 ;
16234   StringValuePair *result = 0 ;
16235
16236   arg1 = (Dali::Property::Map *)jarg1;
16237   arg2 = (Dali::Property::Map::SizeType)jarg2;
16238   {
16239     try {
16240       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16241     } catch (std::out_of_range& e) {
16242       {
16243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16244       };
16245     } catch (std::exception& e) {
16246       {
16247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16248       };
16249     } catch (Dali::DaliException e) {
16250       {
16251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16252       };
16253     } catch (...) {
16254       {
16255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16256       };
16257     }
16258   }
16259
16260   jresult = (void *)result;
16261   return jresult;
16262 }
16263
16264
16265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16266   void * jresult ;
16267   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16268   char *arg2 = (char *) 0 ;
16269   Dali::Property::Value *result = 0 ;
16270
16271   arg1 = (Dali::Property::Map *)jarg1;
16272   arg2 = (char *)jarg2;
16273   {
16274     try {
16275       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16276     } catch (std::out_of_range& e) {
16277       {
16278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16279       };
16280     } catch (std::exception& e) {
16281       {
16282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16283       };
16284     } catch (Dali::DaliException e) {
16285       {
16286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16287       };
16288     } catch (...) {
16289       {
16290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16291       };
16292     }
16293   }
16294
16295   jresult = (void *)result;
16296   return jresult;
16297 }
16298
16299
16300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16301   void * jresult ;
16302   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16303   Dali::Property::Index arg2 ;
16304   Dali::Property::Value *result = 0 ;
16305
16306   arg1 = (Dali::Property::Map *)jarg1;
16307   arg2 = (Dali::Property::Index)jarg2;
16308   {
16309     try {
16310       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16311     } catch (std::out_of_range& e) {
16312       {
16313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16314       };
16315     } catch (std::exception& e) {
16316       {
16317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16318       };
16319     } catch (Dali::DaliException e) {
16320       {
16321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16322       };
16323     } catch (...) {
16324       {
16325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16326       };
16327     }
16328   }
16329
16330   jresult = (void *)result;
16331   return jresult;
16332 }
16333
16334
16335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16336   void * jresult ;
16337   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16338   Dali::Property::Index arg2 ;
16339   std::string *arg3 = 0 ;
16340   Dali::Property::Value *result = 0 ;
16341
16342   arg1 = (Dali::Property::Map *)jarg1;
16343   arg2 = (Dali::Property::Index)jarg2;
16344   if (!jarg3) {
16345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16346     return 0;
16347   }
16348   std::string arg3_str(jarg3);
16349   arg3 = &arg3_str;
16350   {
16351     try {
16352       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16353     } catch (std::out_of_range& e) {
16354       {
16355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16356       };
16357     } catch (std::exception& e) {
16358       {
16359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16360       };
16361     } catch (Dali::DaliException e) {
16362       {
16363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16364       };
16365     } catch (...) {
16366       {
16367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16368       };
16369     }
16370   }
16371
16372   jresult = (void *)result;
16373
16374   //argout typemap for const std::string&
16375
16376   return jresult;
16377 }
16378
16379
16380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16381   void * jresult ;
16382   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16383   std::string *arg2 = 0 ;
16384   Dali::Property::Type arg3 ;
16385   Dali::Property::Value *result = 0 ;
16386
16387   arg1 = (Dali::Property::Map *)jarg1;
16388   if (!jarg2) {
16389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16390     return 0;
16391   }
16392   std::string arg2_str(jarg2);
16393   arg2 = &arg2_str;
16394   arg3 = (Dali::Property::Type)jarg3;
16395   {
16396     try {
16397       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16398     } catch (std::out_of_range& e) {
16399       {
16400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16401       };
16402     } catch (std::exception& e) {
16403       {
16404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16405       };
16406     } catch (Dali::DaliException e) {
16407       {
16408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16409       };
16410     } catch (...) {
16411       {
16412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16413       };
16414     }
16415   }
16416
16417   jresult = (void *)result;
16418
16419   //argout typemap for const std::string&
16420
16421   return jresult;
16422 }
16423
16424
16425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16426   void * jresult ;
16427   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16428   Dali::Property::Index arg2 ;
16429   Dali::Property::Type arg3 ;
16430   Dali::Property::Value *result = 0 ;
16431
16432   arg1 = (Dali::Property::Map *)jarg1;
16433   arg2 = (Dali::Property::Index)jarg2;
16434   arg3 = (Dali::Property::Type)jarg3;
16435   {
16436     try {
16437       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16438     } catch (std::out_of_range& e) {
16439       {
16440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16441       };
16442     } catch (std::exception& e) {
16443       {
16444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16445       };
16446     } catch (Dali::DaliException e) {
16447       {
16448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16449       };
16450     } catch (...) {
16451       {
16452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16453       };
16454     }
16455   }
16456
16457   jresult = (void *)result;
16458   return jresult;
16459 }
16460
16461
16462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16463   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16464
16465   arg1 = (Dali::Property::Map *)jarg1;
16466   {
16467     try {
16468       (arg1)->Clear();
16469     } catch (std::out_of_range& e) {
16470       {
16471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16472       };
16473     } catch (std::exception& e) {
16474       {
16475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16476       };
16477     } catch (Dali::DaliException e) {
16478       {
16479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16480       };
16481     } catch (...) {
16482       {
16483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16484       };
16485     }
16486   }
16487
16488 }
16489
16490
16491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16492   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16493   Dali::Property::Map *arg2 = 0 ;
16494
16495   arg1 = (Dali::Property::Map *)jarg1;
16496   arg2 = (Dali::Property::Map *)jarg2;
16497   if (!arg2) {
16498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16499     return ;
16500   }
16501   {
16502     try {
16503       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16504     } catch (std::out_of_range& e) {
16505       {
16506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16507       };
16508     } catch (std::exception& e) {
16509       {
16510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16511       };
16512     } catch (Dali::DaliException e) {
16513       {
16514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16515       };
16516     } catch (...) {
16517       {
16518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16519       };
16520     }
16521   }
16522
16523 }
16524
16525
16526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16527   void * jresult ;
16528   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16529   std::string *arg2 = 0 ;
16530   Dali::Property::Value *result = 0 ;
16531
16532   arg1 = (Dali::Property::Map *)jarg1;
16533   if (!jarg2) {
16534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16535     return 0;
16536   }
16537   std::string arg2_str(jarg2);
16538   arg2 = &arg2_str;
16539   {
16540     try {
16541       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16542     } catch (std::out_of_range& e) {
16543       {
16544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16545       };
16546     } catch (std::exception& e) {
16547       {
16548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16549       };
16550     } catch (Dali::DaliException e) {
16551       {
16552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16553       };
16554     } catch (...) {
16555       {
16556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16557       };
16558     }
16559   }
16560
16561   jresult = (void *)result;
16562
16563   //argout typemap for const std::string&
16564
16565   return jresult;
16566 }
16567
16568
16569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16570   void * jresult ;
16571   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16572   Dali::Property::Index arg2 ;
16573   Dali::Property::Value *result = 0 ;
16574
16575   arg1 = (Dali::Property::Map *)jarg1;
16576   arg2 = (Dali::Property::Index)jarg2;
16577   {
16578     try {
16579       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16580     } catch (std::out_of_range& e) {
16581       {
16582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16583       };
16584     } catch (std::exception& e) {
16585       {
16586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16587       };
16588     } catch (Dali::DaliException e) {
16589       {
16590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16591       };
16592     } catch (...) {
16593       {
16594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16595       };
16596     }
16597   }
16598
16599   jresult = (void *)result;
16600   return jresult;
16601 }
16602
16603
16604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16605   void * jresult ;
16606   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16607   Dali::Property::Map *arg2 = 0 ;
16608   Dali::Property::Map *result = 0 ;
16609
16610   arg1 = (Dali::Property::Map *)jarg1;
16611   arg2 = (Dali::Property::Map *)jarg2;
16612   if (!arg2) {
16613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16614     return 0;
16615   }
16616   {
16617     try {
16618       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16619     } catch (std::out_of_range& e) {
16620       {
16621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16622       };
16623     } catch (std::exception& e) {
16624       {
16625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16626       };
16627     } catch (Dali::DaliException e) {
16628       {
16629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16630       };
16631     } catch (...) {
16632       {
16633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16634       };
16635     }
16636   }
16637
16638   jresult = (void *)result;
16639   return jresult;
16640 }
16641
16642
16643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16644   void * jresult ;
16645   Dali::Property::Value *result = 0 ;
16646
16647   {
16648     try {
16649       result = (Dali::Property::Value *)new Dali::Property::Value();
16650     } catch (std::out_of_range& e) {
16651       {
16652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16653       };
16654     } catch (std::exception& e) {
16655       {
16656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16657       };
16658     } catch (Dali::DaliException e) {
16659       {
16660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16661       };
16662     } catch (...) {
16663       {
16664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16665       };
16666     }
16667   }
16668
16669   jresult = (void *)result;
16670   return jresult;
16671 }
16672
16673
16674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16675   void * jresult ;
16676   bool arg1 ;
16677   Dali::Property::Value *result = 0 ;
16678
16679   arg1 = jarg1 ? true : false;
16680   {
16681     try {
16682       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16683     } catch (std::out_of_range& e) {
16684       {
16685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16686       };
16687     } catch (std::exception& e) {
16688       {
16689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16690       };
16691     } catch (Dali::DaliException e) {
16692       {
16693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16694       };
16695     } catch (...) {
16696       {
16697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16698       };
16699     }
16700   }
16701
16702   jresult = (void *)result;
16703   return jresult;
16704 }
16705
16706
16707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16708   void * jresult ;
16709   int arg1 ;
16710   Dali::Property::Value *result = 0 ;
16711
16712   arg1 = (int)jarg1;
16713   {
16714     try {
16715       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16716     } catch (std::out_of_range& e) {
16717       {
16718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16719       };
16720     } catch (std::exception& e) {
16721       {
16722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16723       };
16724     } catch (Dali::DaliException e) {
16725       {
16726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16727       };
16728     } catch (...) {
16729       {
16730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16731       };
16732     }
16733   }
16734
16735   jresult = (void *)result;
16736   return jresult;
16737 }
16738
16739
16740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16741   void * jresult ;
16742   float arg1 ;
16743   Dali::Property::Value *result = 0 ;
16744
16745   arg1 = (float)jarg1;
16746   {
16747     try {
16748       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16749     } catch (std::out_of_range& e) {
16750       {
16751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16752       };
16753     } catch (std::exception& e) {
16754       {
16755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16756       };
16757     } catch (Dali::DaliException e) {
16758       {
16759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16760       };
16761     } catch (...) {
16762       {
16763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16764       };
16765     }
16766   }
16767
16768   jresult = (void *)result;
16769   return jresult;
16770 }
16771
16772
16773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16774   void * jresult ;
16775   Dali::Vector2 *arg1 = 0 ;
16776   Dali::Property::Value *result = 0 ;
16777
16778   arg1 = (Dali::Vector2 *)jarg1;
16779   if (!arg1) {
16780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16781     return 0;
16782   }
16783   {
16784     try {
16785       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16786     } catch (std::out_of_range& e) {
16787       {
16788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16789       };
16790     } catch (std::exception& e) {
16791       {
16792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16793       };
16794     } catch (Dali::DaliException e) {
16795       {
16796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16797       };
16798     } catch (...) {
16799       {
16800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16801       };
16802     }
16803   }
16804
16805   jresult = (void *)result;
16806   return jresult;
16807 }
16808
16809
16810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16811   void * jresult ;
16812   Dali::Vector3 *arg1 = 0 ;
16813   Dali::Property::Value *result = 0 ;
16814
16815   arg1 = (Dali::Vector3 *)jarg1;
16816   if (!arg1) {
16817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16818     return 0;
16819   }
16820   {
16821     try {
16822       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16823     } catch (std::out_of_range& e) {
16824       {
16825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16826       };
16827     } catch (std::exception& e) {
16828       {
16829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16830       };
16831     } catch (Dali::DaliException e) {
16832       {
16833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16834       };
16835     } catch (...) {
16836       {
16837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16838       };
16839     }
16840   }
16841
16842   jresult = (void *)result;
16843   return jresult;
16844 }
16845
16846
16847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16848   void * jresult ;
16849   Dali::Vector4 *arg1 = 0 ;
16850   Dali::Property::Value *result = 0 ;
16851
16852   arg1 = (Dali::Vector4 *)jarg1;
16853   if (!arg1) {
16854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16855     return 0;
16856   }
16857   {
16858     try {
16859       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16860     } catch (std::out_of_range& e) {
16861       {
16862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16863       };
16864     } catch (std::exception& e) {
16865       {
16866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16867       };
16868     } catch (Dali::DaliException e) {
16869       {
16870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16871       };
16872     } catch (...) {
16873       {
16874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16875       };
16876     }
16877   }
16878
16879   jresult = (void *)result;
16880   return jresult;
16881 }
16882
16883
16884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16885   void * jresult ;
16886   Dali::Matrix3 *arg1 = 0 ;
16887   Dali::Property::Value *result = 0 ;
16888
16889   arg1 = (Dali::Matrix3 *)jarg1;
16890   if (!arg1) {
16891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16892     return 0;
16893   }
16894   {
16895     try {
16896       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16897     } catch (std::out_of_range& e) {
16898       {
16899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16900       };
16901     } catch (std::exception& e) {
16902       {
16903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16904       };
16905     } catch (Dali::DaliException e) {
16906       {
16907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16908       };
16909     } catch (...) {
16910       {
16911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16912       };
16913     }
16914   }
16915
16916   jresult = (void *)result;
16917   return jresult;
16918 }
16919
16920
16921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16922   void * jresult ;
16923   Dali::Matrix *arg1 = 0 ;
16924   Dali::Property::Value *result = 0 ;
16925
16926   arg1 = (Dali::Matrix *)jarg1;
16927   if (!arg1) {
16928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16929     return 0;
16930   }
16931   {
16932     try {
16933       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16934     } catch (std::out_of_range& e) {
16935       {
16936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16937       };
16938     } catch (std::exception& e) {
16939       {
16940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16941       };
16942     } catch (Dali::DaliException e) {
16943       {
16944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16945       };
16946     } catch (...) {
16947       {
16948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16949       };
16950     }
16951   }
16952
16953   jresult = (void *)result;
16954   return jresult;
16955 }
16956
16957
16958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16959   void * jresult ;
16960   Dali::Rect< int > *arg1 = 0 ;
16961   Dali::Property::Value *result = 0 ;
16962
16963   arg1 = (Dali::Rect< int > *)jarg1;
16964   if (!arg1) {
16965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16966     return 0;
16967   }
16968   {
16969     try {
16970       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16971     } catch (std::out_of_range& e) {
16972       {
16973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16974       };
16975     } catch (std::exception& e) {
16976       {
16977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16978       };
16979     } catch (Dali::DaliException e) {
16980       {
16981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16982       };
16983     } catch (...) {
16984       {
16985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16986       };
16987     }
16988   }
16989
16990   jresult = (void *)result;
16991   return jresult;
16992 }
16993
16994
16995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
16996   void * jresult ;
16997   Dali::AngleAxis *arg1 = 0 ;
16998   Dali::Property::Value *result = 0 ;
16999
17000   arg1 = (Dali::AngleAxis *)jarg1;
17001   if (!arg1) {
17002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17003     return 0;
17004   }
17005   {
17006     try {
17007       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17008     } catch (std::out_of_range& e) {
17009       {
17010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17011       };
17012     } catch (std::exception& e) {
17013       {
17014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17015       };
17016     } catch (Dali::DaliException e) {
17017       {
17018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17019       };
17020     } catch (...) {
17021       {
17022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17023       };
17024     }
17025   }
17026
17027   jresult = (void *)result;
17028   return jresult;
17029 }
17030
17031
17032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17033   void * jresult ;
17034   Dali::Quaternion *arg1 = 0 ;
17035   Dali::Property::Value *result = 0 ;
17036
17037   arg1 = (Dali::Quaternion *)jarg1;
17038   if (!arg1) {
17039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17040     return 0;
17041   }
17042   {
17043     try {
17044       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17045     } catch (std::out_of_range& e) {
17046       {
17047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17048       };
17049     } catch (std::exception& e) {
17050       {
17051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17052       };
17053     } catch (Dali::DaliException e) {
17054       {
17055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17056       };
17057     } catch (...) {
17058       {
17059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17060       };
17061     }
17062   }
17063
17064   jresult = (void *)result;
17065   return jresult;
17066 }
17067
17068
17069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17070   void * jresult ;
17071   std::string *arg1 = 0 ;
17072   Dali::Property::Value *result = 0 ;
17073
17074   if (!jarg1) {
17075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17076     return 0;
17077   }
17078   std::string arg1_str(jarg1);
17079   arg1 = &arg1_str;
17080   {
17081     try {
17082       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17083     } catch (std::out_of_range& e) {
17084       {
17085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17086       };
17087     } catch (std::exception& e) {
17088       {
17089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17090       };
17091     } catch (Dali::DaliException e) {
17092       {
17093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17094       };
17095     } catch (...) {
17096       {
17097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17098       };
17099     }
17100   }
17101
17102   jresult = (void *)result;
17103
17104   //argout typemap for const std::string&
17105
17106   return jresult;
17107 }
17108
17109
17110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17111   void * jresult ;
17112   Dali::Property::Array *arg1 = 0 ;
17113   Dali::Property::Value *result = 0 ;
17114
17115   arg1 = (Dali::Property::Array *)jarg1;
17116   if (!arg1) {
17117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17118     return 0;
17119   }
17120   {
17121     try {
17122       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17123     } catch (std::out_of_range& e) {
17124       {
17125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17126       };
17127     } catch (std::exception& e) {
17128       {
17129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17130       };
17131     } catch (Dali::DaliException e) {
17132       {
17133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17134       };
17135     } catch (...) {
17136       {
17137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17138       };
17139     }
17140   }
17141
17142   jresult = (void *)result;
17143   return jresult;
17144 }
17145
17146
17147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17148   void * jresult ;
17149   Dali::Property::Map *arg1 = 0 ;
17150   Dali::Property::Value *result = 0 ;
17151
17152   arg1 = (Dali::Property::Map *)jarg1;
17153   if (!arg1) {
17154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17155     return 0;
17156   }
17157   {
17158     try {
17159       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17160     } catch (std::out_of_range& e) {
17161       {
17162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17163       };
17164     } catch (std::exception& e) {
17165       {
17166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17167       };
17168     } catch (Dali::DaliException e) {
17169       {
17170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17171       };
17172     } catch (...) {
17173       {
17174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17175       };
17176     }
17177   }
17178
17179   jresult = (void *)result;
17180   return jresult;
17181 }
17182
17183
17184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17185   void * jresult ;
17186   Extents *arg1 = 0 ;
17187   Dali::Property::Value *result = 0 ;
17188
17189   arg1 = (Extents *)jarg1;
17190   if (!arg1) {
17191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17192     return 0;
17193   }
17194   {
17195     try {
17196       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17197     } catch (std::out_of_range& e) {
17198       {
17199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17200       };
17201     } catch (std::exception& e) {
17202       {
17203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17204       };
17205     } catch (...) {
17206       {
17207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17208       };
17209     }
17210   }
17211   jresult = (void *)result;
17212   return jresult;
17213 }
17214
17215
17216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17217   void * jresult ;
17218   Dali::Property::Type arg1 ;
17219   Dali::Property::Value *result = 0 ;
17220
17221   arg1 = (Dali::Property::Type)jarg1;
17222   {
17223     try {
17224       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17225     } catch (std::out_of_range& e) {
17226       {
17227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17228       };
17229     } catch (std::exception& e) {
17230       {
17231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17232       };
17233     } catch (Dali::DaliException e) {
17234       {
17235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17236       };
17237     } catch (...) {
17238       {
17239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17240       };
17241     }
17242   }
17243
17244   jresult = (void *)result;
17245   return jresult;
17246 }
17247
17248
17249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17250   void * jresult ;
17251   Dali::Property::Value *arg1 = 0 ;
17252   Dali::Property::Value *result = 0 ;
17253
17254   arg1 = (Dali::Property::Value *)jarg1;
17255   if (!arg1) {
17256     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17257     return 0;
17258   }
17259   {
17260     try {
17261       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17262     } catch (std::out_of_range& e) {
17263       {
17264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17265       };
17266     } catch (std::exception& e) {
17267       {
17268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17269       };
17270     } catch (Dali::DaliException e) {
17271       {
17272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17273       };
17274     } catch (...) {
17275       {
17276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17277       };
17278     }
17279   }
17280
17281   jresult = (void *)result;
17282   return jresult;
17283 }
17284
17285
17286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17287   void * jresult ;
17288   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17289   Dali::Property::Value *arg2 = 0 ;
17290   Dali::Property::Value *result = 0 ;
17291
17292   arg1 = (Dali::Property::Value *)jarg1;
17293   arg2 = (Dali::Property::Value *)jarg2;
17294   if (!arg2) {
17295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17296     return 0;
17297   }
17298   {
17299     try {
17300       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17301     } catch (std::out_of_range& e) {
17302       {
17303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17304       };
17305     } catch (std::exception& e) {
17306       {
17307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17308       };
17309     } catch (Dali::DaliException e) {
17310       {
17311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17312       };
17313     } catch (...) {
17314       {
17315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17316       };
17317     }
17318   }
17319
17320   jresult = (void *)result;
17321   return jresult;
17322 }
17323
17324
17325 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17326   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17327
17328   arg1 = (Dali::Property::Value *)jarg1;
17329   {
17330     try {
17331       delete arg1;
17332     } catch (std::out_of_range& e) {
17333       {
17334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17335       };
17336     } catch (std::exception& e) {
17337       {
17338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17339       };
17340     } catch (Dali::DaliException e) {
17341       {
17342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17343       };
17344     } catch (...) {
17345       {
17346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17347       };
17348     }
17349   }
17350
17351 }
17352
17353
17354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17355   int jresult ;
17356   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17357   Dali::Property::Type result;
17358
17359   arg1 = (Dali::Property::Value *)jarg1;
17360   {
17361     try {
17362       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17363     } catch (std::out_of_range& e) {
17364       {
17365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17366       };
17367     } catch (std::exception& e) {
17368       {
17369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17370       };
17371     } catch (Dali::DaliException e) {
17372       {
17373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17374       };
17375     } catch (...) {
17376       {
17377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17378       };
17379     }
17380   }
17381
17382   jresult = (int)result;
17383   return jresult;
17384 }
17385
17386
17387 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17388   unsigned int jresult ;
17389   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17390   bool *arg2 = 0 ;
17391   bool result;
17392
17393   arg1 = (Dali::Property::Value *)jarg1;
17394   arg2 = (bool *)jarg2;
17395   {
17396     try {
17397       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17398     } catch (std::out_of_range& e) {
17399       {
17400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17401       };
17402     } catch (std::exception& e) {
17403       {
17404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17405       };
17406     } catch (Dali::DaliException e) {
17407       {
17408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17409       };
17410     } catch (...) {
17411       {
17412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17413       };
17414     }
17415   }
17416
17417   jresult = result;
17418   return jresult;
17419 }
17420
17421
17422 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17423   unsigned int jresult ;
17424   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17425   float *arg2 = 0 ;
17426   bool result;
17427
17428   arg1 = (Dali::Property::Value *)jarg1;
17429   arg2 = (float *)jarg2;
17430   {
17431     try {
17432       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17433     } catch (std::out_of_range& e) {
17434       {
17435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17436       };
17437     } catch (std::exception& e) {
17438       {
17439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17440       };
17441     } catch (Dali::DaliException e) {
17442       {
17443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17444       };
17445     } catch (...) {
17446       {
17447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17448       };
17449     }
17450   }
17451
17452   jresult = result;
17453   return jresult;
17454 }
17455
17456
17457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17458   unsigned int jresult ;
17459   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17460   int *arg2 = 0 ;
17461   bool result;
17462
17463   arg1 = (Dali::Property::Value *)jarg1;
17464   arg2 = (int *)jarg2;
17465   {
17466     try {
17467       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17468     } catch (std::out_of_range& e) {
17469       {
17470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17471       };
17472     } catch (std::exception& e) {
17473       {
17474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17475       };
17476     } catch (Dali::DaliException e) {
17477       {
17478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17479       };
17480     } catch (...) {
17481       {
17482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17483       };
17484     }
17485   }
17486
17487   jresult = result;
17488   return jresult;
17489 }
17490
17491
17492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17493   unsigned int jresult ;
17494   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17495   Dali::Rect< int > *arg2 = 0 ;
17496   bool result;
17497
17498   arg1 = (Dali::Property::Value *)jarg1;
17499   arg2 = (Dali::Rect< int > *)jarg2;
17500   if (!arg2) {
17501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17502     return 0;
17503   }
17504   {
17505     try {
17506       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17507     } catch (std::out_of_range& e) {
17508       {
17509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17510       };
17511     } catch (std::exception& e) {
17512       {
17513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17514       };
17515     } catch (Dali::DaliException e) {
17516       {
17517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17518       };
17519     } catch (...) {
17520       {
17521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17522       };
17523     }
17524   }
17525
17526   jresult = result;
17527   return jresult;
17528 }
17529
17530
17531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17532   unsigned int jresult ;
17533   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17534   Dali::Vector2 *arg2 = 0 ;
17535   bool result;
17536
17537   arg1 = (Dali::Property::Value *)jarg1;
17538   arg2 = (Dali::Vector2 *)jarg2;
17539   if (!arg2) {
17540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17541     return 0;
17542   }
17543   {
17544     try {
17545       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17546     } catch (std::out_of_range& e) {
17547       {
17548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17549       };
17550     } catch (std::exception& e) {
17551       {
17552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17553       };
17554     } catch (Dali::DaliException e) {
17555       {
17556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17557       };
17558     } catch (...) {
17559       {
17560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17561       };
17562     }
17563   }
17564
17565   jresult = result;
17566   return jresult;
17567 }
17568
17569
17570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17571   unsigned int jresult ;
17572   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17573   Dali::Vector3 *arg2 = 0 ;
17574   bool result;
17575
17576   arg1 = (Dali::Property::Value *)jarg1;
17577   arg2 = (Dali::Vector3 *)jarg2;
17578   if (!arg2) {
17579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17580     return 0;
17581   }
17582   {
17583     try {
17584       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17585     } catch (std::out_of_range& e) {
17586       {
17587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17588       };
17589     } catch (std::exception& e) {
17590       {
17591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17592       };
17593     } catch (Dali::DaliException e) {
17594       {
17595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17596       };
17597     } catch (...) {
17598       {
17599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17600       };
17601     }
17602   }
17603
17604   jresult = result;
17605   return jresult;
17606 }
17607
17608
17609 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17610   unsigned int jresult ;
17611   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17612   Dali::Vector4 *arg2 = 0 ;
17613   bool result;
17614
17615   arg1 = (Dali::Property::Value *)jarg1;
17616   arg2 = (Dali::Vector4 *)jarg2;
17617   if (!arg2) {
17618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17619     return 0;
17620   }
17621   {
17622     try {
17623       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17624     } catch (std::out_of_range& e) {
17625       {
17626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17627       };
17628     } catch (std::exception& e) {
17629       {
17630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17631       };
17632     } catch (Dali::DaliException e) {
17633       {
17634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17635       };
17636     } catch (...) {
17637       {
17638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17639       };
17640     }
17641   }
17642
17643   jresult = result;
17644   return jresult;
17645 }
17646
17647
17648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17649   unsigned int jresult ;
17650   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17651   Dali::Matrix3 *arg2 = 0 ;
17652   bool result;
17653
17654   arg1 = (Dali::Property::Value *)jarg1;
17655   arg2 = (Dali::Matrix3 *)jarg2;
17656   if (!arg2) {
17657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17658     return 0;
17659   }
17660   {
17661     try {
17662       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17663     } catch (std::out_of_range& e) {
17664       {
17665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17666       };
17667     } catch (std::exception& e) {
17668       {
17669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17670       };
17671     } catch (Dali::DaliException e) {
17672       {
17673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17674       };
17675     } catch (...) {
17676       {
17677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17678       };
17679     }
17680   }
17681
17682   jresult = result;
17683   return jresult;
17684 }
17685
17686
17687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17688   unsigned int jresult ;
17689   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17690   Dali::Matrix *arg2 = 0 ;
17691   bool result;
17692
17693   arg1 = (Dali::Property::Value *)jarg1;
17694   arg2 = (Dali::Matrix *)jarg2;
17695   if (!arg2) {
17696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17697     return 0;
17698   }
17699   {
17700     try {
17701       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17702     } catch (std::out_of_range& e) {
17703       {
17704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17705       };
17706     } catch (std::exception& e) {
17707       {
17708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17709       };
17710     } catch (Dali::DaliException e) {
17711       {
17712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17713       };
17714     } catch (...) {
17715       {
17716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17717       };
17718     }
17719   }
17720
17721   jresult = result;
17722   return jresult;
17723 }
17724
17725
17726 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17727   unsigned int jresult ;
17728   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17729   Dali::AngleAxis *arg2 = 0 ;
17730   bool result;
17731
17732   arg1 = (Dali::Property::Value *)jarg1;
17733   arg2 = (Dali::AngleAxis *)jarg2;
17734   if (!arg2) {
17735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17736     return 0;
17737   }
17738   {
17739     try {
17740       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17741     } catch (std::out_of_range& e) {
17742       {
17743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17744       };
17745     } catch (std::exception& e) {
17746       {
17747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17748       };
17749     } catch (Dali::DaliException e) {
17750       {
17751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17752       };
17753     } catch (...) {
17754       {
17755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17756       };
17757     }
17758   }
17759
17760   jresult = result;
17761   return jresult;
17762 }
17763
17764
17765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17766   unsigned int jresult ;
17767   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17768   Dali::Quaternion *arg2 = 0 ;
17769   bool result;
17770
17771   arg1 = (Dali::Property::Value *)jarg1;
17772   arg2 = (Dali::Quaternion *)jarg2;
17773   if (!arg2) {
17774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17775     return 0;
17776   }
17777   {
17778     try {
17779       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17780     } catch (std::out_of_range& e) {
17781       {
17782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17783       };
17784     } catch (std::exception& e) {
17785       {
17786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17787       };
17788     } catch (Dali::DaliException e) {
17789       {
17790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17791       };
17792     } catch (...) {
17793       {
17794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17795       };
17796     }
17797   }
17798
17799   jresult = result;
17800   return jresult;
17801 }
17802
17803
17804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17805   unsigned int jresult ;
17806   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17807   std::string *arg2 = 0 ;
17808   bool result;
17809
17810   arg1 = (Dali::Property::Value *)jarg1;
17811
17812   //typemap in
17813   std::string temp;
17814   arg2 = &temp;
17815
17816   {
17817     try {
17818       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17819     } catch (std::out_of_range& e) {
17820       {
17821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17822       };
17823     } catch (std::exception& e) {
17824       {
17825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17826       };
17827     } catch (Dali::DaliException e) {
17828       {
17829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17830       };
17831     } catch (...) {
17832       {
17833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17834       };
17835     }
17836   }
17837
17838   jresult = result;
17839
17840   //Typemap argout in c++ file.
17841   //This will convert c++ string to c# string
17842   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17843
17844   return jresult;
17845 }
17846
17847
17848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17849   unsigned int jresult ;
17850   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17851   Dali::Property::Array *arg2 = 0 ;
17852   bool result;
17853
17854   arg1 = (Dali::Property::Value *)jarg1;
17855   arg2 = (Dali::Property::Array *)jarg2;
17856   if (!arg2) {
17857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17858     return 0;
17859   }
17860   {
17861     try {
17862       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17863     } catch (std::out_of_range& e) {
17864       {
17865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17866       };
17867     } catch (std::exception& e) {
17868       {
17869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17870       };
17871     } catch (Dali::DaliException e) {
17872       {
17873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17874       };
17875     } catch (...) {
17876       {
17877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17878       };
17879     }
17880   }
17881
17882   jresult = result;
17883   return jresult;
17884 }
17885
17886
17887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17888   unsigned int jresult ;
17889   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17890   Dali::Property::Map *arg2 = 0 ;
17891   bool result;
17892
17893   arg1 = (Dali::Property::Value *)jarg1;
17894   arg2 = (Dali::Property::Map *)jarg2;
17895   if (!arg2) {
17896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17897     return 0;
17898   }
17899   {
17900     try {
17901       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17902     } catch (std::out_of_range& e) {
17903       {
17904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17905       };
17906     } catch (std::exception& e) {
17907       {
17908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17909       };
17910     } catch (Dali::DaliException e) {
17911       {
17912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17913       };
17914     } catch (...) {
17915       {
17916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17917       };
17918     }
17919   }
17920
17921   jresult = result;
17922   return jresult;
17923 }
17924
17925
17926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17927   unsigned int jresult ;
17928   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17929   Extents *arg2 = 0 ;
17930   bool result;
17931
17932   arg1 = (Dali::Property::Value *)jarg1;
17933   arg2 = (Extents *)jarg2;
17934   if (!arg2) {
17935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17936     return 0;
17937   }
17938   {
17939     try {
17940       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17941     } catch (std::out_of_range& e) {
17942       {
17943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17944       };
17945     } catch (std::exception& e) {
17946       {
17947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17948       };
17949     } catch (...) {
17950       {
17951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17952       };
17953     }
17954   }
17955   jresult = result;
17956   return jresult;
17957 }
17958
17959
17960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17961   void * jresult ;
17962   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17963   Dali::Property::Array *result = 0 ;
17964
17965   arg1 = (Dali::Property::Value *)jarg1;
17966   {
17967     try {
17968       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17969     } catch (std::out_of_range& e) {
17970       {
17971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17972       };
17973     } catch (std::exception& e) {
17974       {
17975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17976       };
17977     } catch (Dali::DaliException e) {
17978       {
17979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17980       };
17981     } catch (...) {
17982       {
17983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17984       };
17985     }
17986   }
17987
17988   jresult = (void *)result;
17989   return jresult;
17990 }
17991
17992
17993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
17994   void * jresult ;
17995   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17996   Dali::Property::Map *result = 0 ;
17997
17998   arg1 = (Dali::Property::Value *)jarg1;
17999   {
18000     try {
18001       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18002     } catch (std::out_of_range& e) {
18003       {
18004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18005       };
18006     } catch (std::exception& e) {
18007       {
18008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18009       };
18010     } catch (Dali::DaliException e) {
18011       {
18012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18013       };
18014     } catch (...) {
18015       {
18016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18017       };
18018     }
18019   }
18020
18021   jresult = (void *)result;
18022   return jresult;
18023 }
18024
18025
18026 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18027   char * jresult ;
18028   Dali::Property::Type arg1 ;
18029   char *result = 0 ;
18030
18031   arg1 = (Dali::Property::Type)jarg1;
18032   {
18033     try {
18034       result = (char *)Dali::PropertyTypes::GetName(arg1);
18035     } catch (std::out_of_range& e) {
18036       {
18037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18038       };
18039     } catch (std::exception& e) {
18040       {
18041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18042       };
18043     } catch (Dali::DaliException e) {
18044       {
18045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18046       };
18047     } catch (...) {
18048       {
18049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18050       };
18051     }
18052   }
18053
18054   jresult = SWIG_csharp_string_callback((const char *)result);
18055   return jresult;
18056 }
18057
18058
18059 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18060   unsigned int jresult ;
18061   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18062   std::string *arg2 = 0 ;
18063   Dali::Property::Map *arg3 = 0 ;
18064   bool result;
18065
18066   arg1 = (Dali::BaseObject *)jarg1;
18067   if (!jarg2) {
18068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18069     return 0;
18070   }
18071   std::string arg2_str(jarg2);
18072   arg2 = &arg2_str;
18073   arg3 = (Dali::Property::Map *)jarg3;
18074   if (!arg3) {
18075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18076     return 0;
18077   }
18078   {
18079     try {
18080       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18081     } catch (std::out_of_range& e) {
18082       {
18083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18084       };
18085     } catch (std::exception& e) {
18086       {
18087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18088       };
18089     } catch (Dali::DaliException e) {
18090       {
18091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18092       };
18093     } catch (...) {
18094       {
18095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18096       };
18097     }
18098   }
18099
18100   jresult = result;
18101
18102   //argout typemap for const std::string&
18103
18104   return jresult;
18105 }
18106
18107
18108 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18109   char * jresult ;
18110   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18111   std::string *result = 0 ;
18112
18113   arg1 = (Dali::BaseObject *)jarg1;
18114   {
18115     try {
18116       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18117     } catch (std::out_of_range& e) {
18118       {
18119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18120       };
18121     } catch (std::exception& e) {
18122       {
18123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18124       };
18125     } catch (Dali::DaliException e) {
18126       {
18127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18128       };
18129     } catch (...) {
18130       {
18131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18132       };
18133     }
18134   }
18135
18136   jresult = SWIG_csharp_string_callback(result->c_str());
18137   return jresult;
18138 }
18139
18140
18141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18142   unsigned int jresult ;
18143   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18144   Dali::TypeInfo *arg2 = 0 ;
18145   bool result;
18146
18147   arg1 = (Dali::BaseObject *)jarg1;
18148   arg2 = (Dali::TypeInfo *)jarg2;
18149   if (!arg2) {
18150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18151     return 0;
18152   }
18153   {
18154     try {
18155       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18156     } catch (std::out_of_range& e) {
18157       {
18158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18159       };
18160     } catch (std::exception& e) {
18161       {
18162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18163       };
18164     } catch (Dali::DaliException e) {
18165       {
18166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18167       };
18168     } catch (...) {
18169       {
18170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18171       };
18172     }
18173   }
18174
18175   jresult = result;
18176   return jresult;
18177 }
18178
18179
18180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18181   unsigned int jresult ;
18182   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18183   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18184   std::string *arg3 = 0 ;
18185   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18186   bool result;
18187
18188   arg1 = (Dali::BaseObject *)jarg1;
18189   arg2 = (ConnectionTrackerInterface *)jarg2;
18190   if (!jarg3) {
18191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18192     return 0;
18193   }
18194   std::string arg3_str(jarg3);
18195   arg3 = &arg3_str;
18196   arg4 = (FunctorDelegate *)jarg4;
18197   {
18198     try {
18199       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18200     } catch (std::out_of_range& e) {
18201       {
18202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18203       };
18204     } catch (std::exception& e) {
18205       {
18206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18207       };
18208     } catch (Dali::DaliException e) {
18209       {
18210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18211       };
18212     } catch (...) {
18213       {
18214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18215       };
18216     }
18217   }
18218
18219   jresult = result;
18220
18221   //argout typemap for const std::string&
18222
18223   return jresult;
18224 }
18225
18226
18227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18228   void * jresult ;
18229   Dali::BaseHandle *arg1 = 0 ;
18230   Dali::BaseObject *result = 0 ;
18231
18232   arg1 = (Dali::BaseHandle *)jarg1;
18233   if (!arg1) {
18234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18235     return 0;
18236   }
18237   {
18238     try {
18239       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18240     } catch (std::out_of_range& e) {
18241       {
18242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18243       };
18244     } catch (std::exception& e) {
18245       {
18246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18247       };
18248     } catch (Dali::DaliException e) {
18249       {
18250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18251       };
18252     } catch (...) {
18253       {
18254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18255       };
18256     }
18257   }
18258
18259   jresult = (void *)result;
18260   return jresult;
18261 }
18262
18263
18264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18265   void * jresult ;
18266   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18267   Dali::BaseHandle *result = 0 ;
18268
18269   arg1 = (Dali::BaseObject *)jarg1;
18270   {
18271     try {
18272       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18273     } catch (std::out_of_range& e) {
18274       {
18275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18276       };
18277     } catch (std::exception& e) {
18278       {
18279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18280       };
18281     } catch (Dali::DaliException e) {
18282       {
18283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18284       };
18285     } catch (...) {
18286       {
18287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18288       };
18289     }
18290   }
18291
18292   jresult = (void *)result;
18293   return jresult;
18294 }
18295
18296
18297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18298   void * jresult ;
18299   Dali::BaseHandle *result = 0 ;
18300
18301   {
18302     try {
18303       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18304     } catch (std::out_of_range& e) {
18305       {
18306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18307       };
18308     } catch (std::exception& e) {
18309       {
18310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18311       };
18312     } catch (Dali::DaliException e) {
18313       {
18314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18315       };
18316     } catch (...) {
18317       {
18318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18319       };
18320     }
18321   }
18322
18323   jresult = (void *)result;
18324   return jresult;
18325 }
18326
18327
18328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18329   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18330
18331   arg1 = (Dali::BaseHandle *)jarg1;
18332   {
18333     try {
18334       delete arg1;
18335     } catch (std::out_of_range& e) {
18336       {
18337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18338       };
18339     } catch (std::exception& e) {
18340       {
18341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18342       };
18343     } catch (Dali::DaliException e) {
18344       {
18345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18346       };
18347     } catch (...) {
18348       {
18349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18350       };
18351     }
18352   }
18353
18354 }
18355
18356
18357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18358   void * jresult ;
18359   Dali::BaseHandle *arg1 = 0 ;
18360   Dali::BaseHandle *result = 0 ;
18361
18362   arg1 = (Dali::BaseHandle *)jarg1;
18363   if (!arg1) {
18364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18365     return 0;
18366   }
18367   {
18368     try {
18369       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18370     } catch (std::out_of_range& e) {
18371       {
18372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18373       };
18374     } catch (std::exception& e) {
18375       {
18376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18377       };
18378     } catch (Dali::DaliException e) {
18379       {
18380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18381       };
18382     } catch (...) {
18383       {
18384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18385       };
18386     }
18387   }
18388
18389   jresult = (void *)result;
18390   return jresult;
18391 }
18392
18393
18394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18395   void * jresult ;
18396   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18397   Dali::BaseHandle *arg2 = 0 ;
18398   Dali::BaseHandle *result = 0 ;
18399
18400   arg1 = (Dali::BaseHandle *)jarg1;
18401   arg2 = (Dali::BaseHandle *)jarg2;
18402   if (!arg2) {
18403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18404     return 0;
18405   }
18406   {
18407     try {
18408       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18409     } catch (std::out_of_range& e) {
18410       {
18411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18412       };
18413     } catch (std::exception& e) {
18414       {
18415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18416       };
18417     } catch (Dali::DaliException e) {
18418       {
18419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18420       };
18421     } catch (...) {
18422       {
18423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18424       };
18425     }
18426   }
18427
18428   jresult = (void *)result;
18429   return jresult;
18430 }
18431
18432
18433 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18434   unsigned int jresult ;
18435   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18436   std::string *arg2 = 0 ;
18437   Dali::Property::Map *arg3 = 0 ;
18438   bool result;
18439
18440   arg1 = (Dali::BaseHandle *)jarg1;
18441   if (!jarg2) {
18442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18443     return 0;
18444   }
18445   std::string arg2_str(jarg2);
18446   arg2 = &arg2_str;
18447   arg3 = (Dali::Property::Map *)jarg3;
18448   if (!arg3) {
18449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18450     return 0;
18451   }
18452   {
18453     try {
18454       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18455     } catch (std::out_of_range& e) {
18456       {
18457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18458       };
18459     } catch (std::exception& e) {
18460       {
18461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18462       };
18463     } catch (Dali::DaliException e) {
18464       {
18465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18466       };
18467     } catch (...) {
18468       {
18469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18470       };
18471     }
18472   }
18473
18474   jresult = result;
18475
18476   //argout typemap for const std::string&
18477
18478   return jresult;
18479 }
18480
18481
18482 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18483   char * jresult ;
18484   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18485   std::string *result = 0 ;
18486
18487   arg1 = (Dali::BaseHandle *)jarg1;
18488   {
18489     try {
18490       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18491     } catch (std::out_of_range& e) {
18492       {
18493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18494       };
18495     } catch (std::exception& e) {
18496       {
18497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18498       };
18499     } catch (Dali::DaliException e) {
18500       {
18501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18502       };
18503     } catch (...) {
18504       {
18505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18506       };
18507     }
18508   }
18509
18510   jresult = SWIG_csharp_string_callback(result->c_str());
18511   return jresult;
18512 }
18513
18514
18515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18516   unsigned int jresult ;
18517   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18518   Dali::TypeInfo *arg2 = 0 ;
18519   bool result;
18520
18521   arg1 = (Dali::BaseHandle *)jarg1;
18522   arg2 = (Dali::TypeInfo *)jarg2;
18523   if (!arg2) {
18524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18525     return 0;
18526   }
18527   {
18528     try {
18529       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18530     } catch (std::out_of_range& e) {
18531       {
18532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18533       };
18534     } catch (std::exception& e) {
18535       {
18536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18537       };
18538     } catch (Dali::DaliException e) {
18539       {
18540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18541       };
18542     } catch (...) {
18543       {
18544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18545       };
18546     }
18547   }
18548
18549   jresult = result;
18550   return jresult;
18551 }
18552
18553
18554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18555   void * jresult ;
18556   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18557   Dali::BaseObject *result = 0 ;
18558
18559   arg1 = (Dali::BaseHandle *)jarg1;
18560   {
18561     try {
18562       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18563     } catch (std::out_of_range& e) {
18564       {
18565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18566       };
18567     } catch (std::exception& e) {
18568       {
18569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18570       };
18571     } catch (Dali::DaliException e) {
18572       {
18573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18574       };
18575     } catch (...) {
18576       {
18577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18578       };
18579     }
18580   }
18581
18582   jresult = (void *)result;
18583   return jresult;
18584 }
18585
18586
18587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18588   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18589
18590   arg1 = (Dali::BaseHandle *)jarg1;
18591   {
18592     try {
18593       (arg1)->Reset();
18594     } catch (std::out_of_range& e) {
18595       {
18596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18597       };
18598     } catch (std::exception& e) {
18599       {
18600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18601       };
18602     } catch (Dali::DaliException e) {
18603       {
18604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18605       };
18606     } catch (...) {
18607       {
18608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18609       };
18610     }
18611   }
18612
18613 }
18614
18615
18616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18617   unsigned int jresult ;
18618   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18619   Dali::BaseHandle *arg2 = 0 ;
18620   bool result;
18621
18622   arg1 = (Dali::BaseHandle *)jarg1;
18623   arg2 = (Dali::BaseHandle *)jarg2;
18624   if (!arg2) {
18625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18626     return 0;
18627   }
18628   {
18629     try {
18630       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18631     } catch (std::out_of_range& e) {
18632       {
18633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18634       };
18635     } catch (std::exception& e) {
18636       {
18637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18638       };
18639     } catch (Dali::DaliException e) {
18640       {
18641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18642       };
18643     } catch (...) {
18644       {
18645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18646       };
18647     }
18648   }
18649
18650   jresult = result;
18651   return jresult;
18652 }
18653
18654
18655 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18656   unsigned int jresult ;
18657   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18658   Dali::BaseHandle *arg2 = 0 ;
18659   bool result;
18660
18661   arg1 = (Dali::BaseHandle *)jarg1;
18662   arg2 = (Dali::BaseHandle *)jarg2;
18663   if (!arg2) {
18664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18665     return 0;
18666   }
18667   {
18668     try {
18669       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18670     } catch (std::out_of_range& e) {
18671       {
18672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18673       };
18674     } catch (std::exception& e) {
18675       {
18676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18677       };
18678     } catch (Dali::DaliException e) {
18679       {
18680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18681       };
18682     } catch (...) {
18683       {
18684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18685       };
18686     }
18687   }
18688
18689   jresult = result;
18690   return jresult;
18691 }
18692
18693
18694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18695   void * jresult ;
18696   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18697   Dali::RefObject *result = 0 ;
18698
18699   arg1 = (Dali::BaseHandle *)jarg1;
18700   {
18701     try {
18702       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18703     } catch (std::out_of_range& e) {
18704       {
18705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18706       };
18707     } catch (std::exception& e) {
18708       {
18709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18710       };
18711     } catch (Dali::DaliException e) {
18712       {
18713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18714       };
18715     } catch (...) {
18716       {
18717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18718       };
18719     }
18720   }
18721
18722   jresult = (void *)result;
18723   return jresult;
18724 }
18725
18726
18727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18728   unsigned int jresult ;
18729   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18730   bool result;
18731
18732   arg1 = (Dali::BaseHandle *)jarg1;
18733   {
18734     try {
18735       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18736     } catch (std::out_of_range& e) {
18737       {
18738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18739       };
18740     } catch (std::exception& e) {
18741       {
18742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18743       };
18744     } catch (Dali::DaliException e) {
18745       {
18746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18747       };
18748     } catch (...) {
18749       {
18750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18751       };
18752     }
18753   }
18754
18755   jresult = result;
18756   return jresult;
18757 }
18758
18759
18760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18761   unsigned int jresult ;
18762   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18763   Dali::BaseHandle *arg2 = 0 ;
18764   bool result;
18765
18766   arg1 = (Dali::BaseHandle *)jarg1;
18767   arg2 = (Dali::BaseHandle *)jarg2;
18768   if (!arg2) {
18769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18770     return 0;
18771   }
18772   {
18773     try {
18774       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18775     } catch (std::out_of_range& e) {
18776       {
18777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18778       };
18779     } catch (std::exception& e) {
18780       {
18781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18782       };
18783     } catch (Dali::DaliException e) {
18784       {
18785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18786       };
18787     } catch (...) {
18788       {
18789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18790       };
18791     }
18792   }
18793
18794   jresult = result;
18795   return jresult;
18796 }
18797
18798
18799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18800   unsigned int jresult ;
18801   Dali::BaseHandle *arg1 = 0 ;
18802   Dali::BaseHandle *arg2 = 0 ;
18803   bool result;
18804
18805   arg1 = (Dali::BaseHandle *)jarg1;
18806   if (!arg1) {
18807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18808     return 0;
18809   }
18810   arg2 = (Dali::BaseHandle *)jarg2;
18811   if (!arg2) {
18812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18813     return 0;
18814   }
18815   {
18816     try {
18817       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18818     } catch (std::out_of_range& e) {
18819       {
18820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18821       };
18822     } catch (std::exception& e) {
18823       {
18824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18825       };
18826     } catch (Dali::DaliException e) {
18827       {
18828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18829       };
18830     } catch (...) {
18831       {
18832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18833       };
18834     }
18835   }
18836
18837   jresult = result;
18838   return jresult;
18839 }
18840
18841
18842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18843   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18844
18845   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18846   {
18847     try {
18848       delete arg1;
18849     } catch (std::out_of_range& e) {
18850       {
18851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18852       };
18853     } catch (std::exception& e) {
18854       {
18855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18856       };
18857     } catch (Dali::DaliException e) {
18858       {
18859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18860       };
18861     } catch (...) {
18862       {
18863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18864       };
18865     }
18866   }
18867
18868 }
18869
18870
18871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18872   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18873   SlotObserver *arg2 = (SlotObserver *) 0 ;
18874   CallbackBase *arg3 = (CallbackBase *) 0 ;
18875
18876   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18877   arg2 = (SlotObserver *)jarg2;
18878   arg3 = (CallbackBase *)jarg3;
18879   {
18880     try {
18881       (arg1)->SignalConnected(arg2,arg3);
18882     } catch (std::out_of_range& e) {
18883       {
18884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18885       };
18886     } catch (std::exception& e) {
18887       {
18888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18889       };
18890     } catch (Dali::DaliException e) {
18891       {
18892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18893       };
18894     } catch (...) {
18895       {
18896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18897       };
18898     }
18899   }
18900
18901 }
18902
18903
18904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18905   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18906
18907   arg1 = (Dali::SignalObserver *)jarg1;
18908   {
18909     try {
18910       delete arg1;
18911     } catch (std::out_of_range& e) {
18912       {
18913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18914       };
18915     } catch (std::exception& e) {
18916       {
18917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18918       };
18919     } catch (Dali::DaliException e) {
18920       {
18921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18922       };
18923     } catch (...) {
18924       {
18925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18926       };
18927     }
18928   }
18929
18930 }
18931
18932
18933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18934   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18935   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18936   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18937
18938   arg1 = (Dali::SignalObserver *)jarg1;
18939   arg2 = (Dali::SlotObserver *)jarg2;
18940   arg3 = (Dali::CallbackBase *)jarg3;
18941   {
18942     try {
18943       (arg1)->SignalDisconnected(arg2,arg3);
18944     } catch (std::out_of_range& e) {
18945       {
18946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18947       };
18948     } catch (std::exception& e) {
18949       {
18950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18951       };
18952     } catch (Dali::DaliException e) {
18953       {
18954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18955       };
18956     } catch (...) {
18957       {
18958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18959       };
18960     }
18961   }
18962
18963 }
18964
18965
18966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18967   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18968
18969   arg1 = (Dali::SlotObserver *)jarg1;
18970   {
18971     try {
18972       delete arg1;
18973     } catch (std::out_of_range& e) {
18974       {
18975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18976       };
18977     } catch (std::exception& e) {
18978       {
18979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18980       };
18981     } catch (Dali::DaliException e) {
18982       {
18983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18984       };
18985     } catch (...) {
18986       {
18987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18988       };
18989     }
18990   }
18991
18992 }
18993
18994
18995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
18996   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18997   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
18998
18999   arg1 = (Dali::SlotObserver *)jarg1;
19000   arg2 = (Dali::CallbackBase *)jarg2;
19001   {
19002     try {
19003       (arg1)->SlotDisconnected(arg2);
19004     } catch (std::out_of_range& e) {
19005       {
19006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19007       };
19008     } catch (std::exception& e) {
19009       {
19010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19011       };
19012     } catch (Dali::DaliException e) {
19013       {
19014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19015       };
19016     } catch (...) {
19017       {
19018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19019       };
19020     }
19021   }
19022
19023 }
19024
19025
19026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19027   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19028
19029   arg1 = (Dali::ConnectionTracker *)jarg1;
19030   {
19031     try {
19032       delete arg1;
19033     } catch (std::out_of_range& e) {
19034       {
19035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19036       };
19037     } catch (std::exception& e) {
19038       {
19039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19040       };
19041     } catch (Dali::DaliException e) {
19042       {
19043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19044       };
19045     } catch (...) {
19046       {
19047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19048       };
19049     }
19050   }
19051
19052 }
19053
19054
19055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19056   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19057
19058   arg1 = (Dali::ConnectionTracker *)jarg1;
19059   {
19060     try {
19061       (arg1)->DisconnectAll();
19062     } catch (std::out_of_range& e) {
19063       {
19064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19065       };
19066     } catch (std::exception& e) {
19067       {
19068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19069       };
19070     } catch (Dali::DaliException e) {
19071       {
19072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19073       };
19074     } catch (...) {
19075       {
19076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19077       };
19078     }
19079   }
19080
19081 }
19082
19083
19084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19085   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19086   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19087   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19088
19089   arg1 = (Dali::ConnectionTracker *)jarg1;
19090   arg2 = (Dali::SlotObserver *)jarg2;
19091   arg3 = (Dali::CallbackBase *)jarg3;
19092   {
19093     try {
19094       (arg1)->SignalConnected(arg2,arg3);
19095     } catch (std::out_of_range& e) {
19096       {
19097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19098       };
19099     } catch (std::exception& e) {
19100       {
19101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19102       };
19103     } catch (Dali::DaliException e) {
19104       {
19105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19106       };
19107     } catch (...) {
19108       {
19109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19110       };
19111     }
19112   }
19113
19114 }
19115
19116
19117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19118   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19119   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19120   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19121
19122   arg1 = (Dali::ConnectionTracker *)jarg1;
19123   arg2 = (Dali::SlotObserver *)jarg2;
19124   arg3 = (Dali::CallbackBase *)jarg3;
19125   {
19126     try {
19127       (arg1)->SignalDisconnected(arg2,arg3);
19128     } catch (std::out_of_range& e) {
19129       {
19130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19131       };
19132     } catch (std::exception& e) {
19133       {
19134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19135       };
19136     } catch (Dali::DaliException e) {
19137       {
19138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19139       };
19140     } catch (...) {
19141       {
19142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19143       };
19144     }
19145   }
19146
19147 }
19148
19149
19150 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19151   unsigned long jresult ;
19152   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19153   std::size_t result;
19154
19155   arg1 = (Dali::ConnectionTracker *)jarg1;
19156   {
19157     try {
19158       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19159     } catch (std::out_of_range& e) {
19160       {
19161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19162       };
19163     } catch (std::exception& e) {
19164       {
19165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19166       };
19167     } catch (Dali::DaliException e) {
19168       {
19169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19170       };
19171     } catch (...) {
19172       {
19173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19174       };
19175     }
19176   }
19177
19178   jresult = (unsigned long)result;
19179   return jresult;
19180 }
19181
19182
19183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19184   void * jresult ;
19185   Dali::ObjectRegistry *result = 0 ;
19186
19187   {
19188     try {
19189       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19190     } catch (std::out_of_range& e) {
19191       {
19192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19193       };
19194     } catch (std::exception& e) {
19195       {
19196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19197       };
19198     } catch (Dali::DaliException e) {
19199       {
19200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19201       };
19202     } catch (...) {
19203       {
19204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19205       };
19206     }
19207   }
19208
19209   jresult = (void *)result;
19210   return jresult;
19211 }
19212
19213
19214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19215   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19216
19217   arg1 = (Dali::ObjectRegistry *)jarg1;
19218   {
19219     try {
19220       delete arg1;
19221     } catch (std::out_of_range& e) {
19222       {
19223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19224       };
19225     } catch (std::exception& e) {
19226       {
19227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19228       };
19229     } catch (Dali::DaliException e) {
19230       {
19231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19232       };
19233     } catch (...) {
19234       {
19235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19236       };
19237     }
19238   }
19239
19240 }
19241
19242
19243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19244   void * jresult ;
19245   Dali::ObjectRegistry *arg1 = 0 ;
19246   Dali::ObjectRegistry *result = 0 ;
19247
19248   arg1 = (Dali::ObjectRegistry *)jarg1;
19249   if (!arg1) {
19250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19251     return 0;
19252   }
19253   {
19254     try {
19255       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19256     } catch (std::out_of_range& e) {
19257       {
19258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19259       };
19260     } catch (std::exception& e) {
19261       {
19262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19263       };
19264     } catch (Dali::DaliException e) {
19265       {
19266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19267       };
19268     } catch (...) {
19269       {
19270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19271       };
19272     }
19273   }
19274
19275   jresult = (void *)result;
19276   return jresult;
19277 }
19278
19279
19280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19281   void * jresult ;
19282   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19283   Dali::ObjectRegistry *arg2 = 0 ;
19284   Dali::ObjectRegistry *result = 0 ;
19285
19286   arg1 = (Dali::ObjectRegistry *)jarg1;
19287   arg2 = (Dali::ObjectRegistry *)jarg2;
19288   if (!arg2) {
19289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19290     return 0;
19291   }
19292   {
19293     try {
19294       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19295     } catch (std::out_of_range& e) {
19296       {
19297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19298       };
19299     } catch (std::exception& e) {
19300       {
19301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19302       };
19303     } catch (Dali::DaliException e) {
19304       {
19305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19306       };
19307     } catch (...) {
19308       {
19309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19310       };
19311     }
19312   }
19313
19314   jresult = (void *)result;
19315   return jresult;
19316 }
19317
19318
19319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19320   void * jresult ;
19321   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19322   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19323
19324   arg1 = (Dali::ObjectRegistry *)jarg1;
19325   {
19326     try {
19327       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19328     } catch (std::out_of_range& e) {
19329       {
19330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19331       };
19332     } catch (std::exception& e) {
19333       {
19334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19335       };
19336     } catch (Dali::DaliException e) {
19337       {
19338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19339       };
19340     } catch (...) {
19341       {
19342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19343       };
19344     }
19345   }
19346
19347   jresult = (void *)result;
19348   return jresult;
19349 }
19350
19351
19352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19353   void * jresult ;
19354   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19355   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19356
19357   arg1 = (Dali::ObjectRegistry *)jarg1;
19358   {
19359     try {
19360       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19361     } catch (std::out_of_range& e) {
19362       {
19363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19364       };
19365     } catch (std::exception& e) {
19366       {
19367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19368       };
19369     } catch (Dali::DaliException e) {
19370       {
19371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19372       };
19373     } catch (...) {
19374       {
19375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19376       };
19377     }
19378   }
19379
19380   jresult = (void *)result;
19381   return jresult;
19382 }
19383
19384
19385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19386   void * jresult ;
19387   Dali::PropertyCondition *result = 0 ;
19388
19389   {
19390     try {
19391       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19392     } catch (std::out_of_range& e) {
19393       {
19394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19395       };
19396     } catch (std::exception& e) {
19397       {
19398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19399       };
19400     } catch (Dali::DaliException e) {
19401       {
19402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19403       };
19404     } catch (...) {
19405       {
19406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19407       };
19408     }
19409   }
19410
19411   jresult = (void *)result;
19412   return jresult;
19413 }
19414
19415
19416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19417   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19418
19419   arg1 = (Dali::PropertyCondition *)jarg1;
19420   {
19421     try {
19422       delete arg1;
19423     } catch (std::out_of_range& e) {
19424       {
19425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19426       };
19427     } catch (std::exception& e) {
19428       {
19429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19430       };
19431     } catch (Dali::DaliException e) {
19432       {
19433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19434       };
19435     } catch (...) {
19436       {
19437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19438       };
19439     }
19440   }
19441
19442 }
19443
19444
19445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19446   void * jresult ;
19447   Dali::PropertyCondition *arg1 = 0 ;
19448   Dali::PropertyCondition *result = 0 ;
19449
19450   arg1 = (Dali::PropertyCondition *)jarg1;
19451   if (!arg1) {
19452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19453     return 0;
19454   }
19455   {
19456     try {
19457       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19458     } catch (std::out_of_range& e) {
19459       {
19460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19461       };
19462     } catch (std::exception& e) {
19463       {
19464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19465       };
19466     } catch (Dali::DaliException e) {
19467       {
19468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19469       };
19470     } catch (...) {
19471       {
19472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19473       };
19474     }
19475   }
19476
19477   jresult = (void *)result;
19478   return jresult;
19479 }
19480
19481
19482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19483   void * jresult ;
19484   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19485   Dali::PropertyCondition *arg2 = 0 ;
19486   Dali::PropertyCondition *result = 0 ;
19487
19488   arg1 = (Dali::PropertyCondition *)jarg1;
19489   arg2 = (Dali::PropertyCondition *)jarg2;
19490   if (!arg2) {
19491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19492     return 0;
19493   }
19494   {
19495     try {
19496       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19497     } catch (std::out_of_range& e) {
19498       {
19499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19500       };
19501     } catch (std::exception& e) {
19502       {
19503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19504       };
19505     } catch (Dali::DaliException e) {
19506       {
19507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19508       };
19509     } catch (...) {
19510       {
19511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19512       };
19513     }
19514   }
19515
19516   jresult = (void *)result;
19517   return jresult;
19518 }
19519
19520
19521 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19522   unsigned long jresult ;
19523   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19524   std::size_t result;
19525
19526   arg1 = (Dali::PropertyCondition *)jarg1;
19527   {
19528     try {
19529       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19530     } catch (std::out_of_range& e) {
19531       {
19532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19533       };
19534     } catch (std::exception& e) {
19535       {
19536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19537       };
19538     } catch (...) {
19539       {
19540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19541       };
19542     }
19543   }
19544   jresult = (unsigned long)result;
19545   return jresult;
19546 }
19547
19548
19549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19550   float jresult ;
19551   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19552   std::size_t arg2 ;
19553   float result;
19554
19555   arg1 = (Dali::PropertyCondition *)jarg1;
19556   arg2 = (std::size_t)jarg2;
19557   {
19558     try {
19559       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19560     } catch (std::out_of_range& e) {
19561       {
19562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19563       };
19564     } catch (std::exception& e) {
19565       {
19566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19567       };
19568     } catch (...) {
19569       {
19570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19571       };
19572     }
19573   }
19574   jresult = result;
19575   return jresult;
19576 }
19577
19578
19579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19580   void * jresult ;
19581   float arg1 ;
19582   Dali::PropertyCondition result;
19583
19584   arg1 = (float)jarg1;
19585   {
19586     try {
19587       result = Dali::LessThanCondition(arg1);
19588     } catch (std::out_of_range& e) {
19589       {
19590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19591       };
19592     } catch (std::exception& e) {
19593       {
19594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19595       };
19596     } catch (Dali::DaliException e) {
19597       {
19598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19599       };
19600     } catch (...) {
19601       {
19602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19603       };
19604     }
19605   }
19606
19607   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19608   return jresult;
19609 }
19610
19611
19612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19613   void * jresult ;
19614   float arg1 ;
19615   Dali::PropertyCondition result;
19616
19617   arg1 = (float)jarg1;
19618   {
19619     try {
19620       result = Dali::GreaterThanCondition(arg1);
19621     } catch (std::out_of_range& e) {
19622       {
19623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19624       };
19625     } catch (std::exception& e) {
19626       {
19627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19628       };
19629     } catch (Dali::DaliException e) {
19630       {
19631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19632       };
19633     } catch (...) {
19634       {
19635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19636       };
19637     }
19638   }
19639
19640   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19641   return jresult;
19642 }
19643
19644
19645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19646   void * jresult ;
19647   float arg1 ;
19648   float arg2 ;
19649   Dali::PropertyCondition result;
19650
19651   arg1 = (float)jarg1;
19652   arg2 = (float)jarg2;
19653   {
19654     try {
19655       result = Dali::InsideCondition(arg1,arg2);
19656     } catch (std::out_of_range& e) {
19657       {
19658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19659       };
19660     } catch (std::exception& e) {
19661       {
19662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19663       };
19664     } catch (Dali::DaliException e) {
19665       {
19666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19667       };
19668     } catch (...) {
19669       {
19670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19671       };
19672     }
19673   }
19674
19675   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19676   return jresult;
19677 }
19678
19679
19680 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19681   void * jresult ;
19682   float arg1 ;
19683   float arg2 ;
19684   Dali::PropertyCondition result;
19685
19686   arg1 = (float)jarg1;
19687   arg2 = (float)jarg2;
19688   {
19689     try {
19690       result = Dali::OutsideCondition(arg1,arg2);
19691     } catch (std::out_of_range& e) {
19692       {
19693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19694       };
19695     } catch (std::exception& e) {
19696       {
19697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19698       };
19699     } catch (Dali::DaliException e) {
19700       {
19701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19702       };
19703     } catch (...) {
19704       {
19705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19706       };
19707     }
19708   }
19709
19710   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19711   return jresult;
19712 }
19713
19714
19715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19716   void * jresult ;
19717   float arg1 ;
19718   float arg2 ;
19719   Dali::PropertyCondition result;
19720
19721   arg1 = (float)jarg1;
19722   arg2 = (float)jarg2;
19723   {
19724     try {
19725       result = Dali::StepCondition(arg1,arg2);
19726     } catch (std::out_of_range& e) {
19727       {
19728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19729       };
19730     } catch (std::exception& e) {
19731       {
19732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19733       };
19734     } catch (Dali::DaliException e) {
19735       {
19736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19737       };
19738     } catch (...) {
19739       {
19740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19741       };
19742     }
19743   }
19744
19745   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19746   return jresult;
19747 }
19748
19749
19750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19751   void * jresult ;
19752   float arg1 ;
19753   Dali::PropertyCondition result;
19754
19755   arg1 = (float)jarg1;
19756   {
19757     try {
19758       result = Dali::StepCondition(arg1);
19759     } catch (std::out_of_range& e) {
19760       {
19761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19762       };
19763     } catch (std::exception& e) {
19764       {
19765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19766       };
19767     } catch (Dali::DaliException e) {
19768       {
19769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19770       };
19771     } catch (...) {
19772       {
19773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19774       };
19775     }
19776   }
19777
19778   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19779   return jresult;
19780 }
19781
19782
19783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19784   void * jresult ;
19785   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19786   Dali::PropertyCondition result;
19787
19788   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19789   if (!arg1) {
19790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19791     return 0;
19792   }
19793   {
19794     try {
19795       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19796     } catch (std::out_of_range& e) {
19797       {
19798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19799       };
19800     } catch (std::exception& e) {
19801       {
19802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19803       };
19804     } catch (Dali::DaliException e) {
19805       {
19806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19807       };
19808     } catch (...) {
19809       {
19810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19811       };
19812     }
19813   }
19814
19815   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19816   return jresult;
19817 }
19818
19819
19820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19821   void * jresult ;
19822   Dali::PropertyNotification *result = 0 ;
19823
19824   {
19825     try {
19826       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19827     } catch (std::out_of_range& e) {
19828       {
19829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19830       };
19831     } catch (std::exception& e) {
19832       {
19833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19834       };
19835     } catch (Dali::DaliException e) {
19836       {
19837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19838       };
19839     } catch (...) {
19840       {
19841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19842       };
19843     }
19844   }
19845
19846   jresult = (void *)result;
19847   return jresult;
19848 }
19849
19850
19851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19852   void * jresult ;
19853   Dali::BaseHandle arg1 ;
19854   Dali::BaseHandle *argp1 ;
19855   Dali::PropertyNotification result;
19856
19857   argp1 = (Dali::BaseHandle *)jarg1;
19858   if (!argp1) {
19859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19860     return 0;
19861   }
19862   arg1 = *argp1;
19863   {
19864     try {
19865       result = Dali::PropertyNotification::DownCast(arg1);
19866     } catch (std::out_of_range& e) {
19867       {
19868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19869       };
19870     } catch (std::exception& e) {
19871       {
19872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19873       };
19874     } catch (Dali::DaliException e) {
19875       {
19876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19877       };
19878     } catch (...) {
19879       {
19880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19881       };
19882     }
19883   }
19884
19885   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19886   return jresult;
19887 }
19888
19889
19890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19891   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19892
19893   arg1 = (Dali::PropertyNotification *)jarg1;
19894   {
19895     try {
19896       delete arg1;
19897     } catch (std::out_of_range& e) {
19898       {
19899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19900       };
19901     } catch (std::exception& e) {
19902       {
19903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19904       };
19905     } catch (Dali::DaliException e) {
19906       {
19907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19908       };
19909     } catch (...) {
19910       {
19911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19912       };
19913     }
19914   }
19915
19916 }
19917
19918
19919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19920   void * jresult ;
19921   Dali::PropertyNotification *arg1 = 0 ;
19922   Dali::PropertyNotification *result = 0 ;
19923
19924   arg1 = (Dali::PropertyNotification *)jarg1;
19925   if (!arg1) {
19926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19927     return 0;
19928   }
19929   {
19930     try {
19931       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19932     } catch (std::out_of_range& e) {
19933       {
19934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19935       };
19936     } catch (std::exception& e) {
19937       {
19938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19939       };
19940     } catch (Dali::DaliException e) {
19941       {
19942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19943       };
19944     } catch (...) {
19945       {
19946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19947       };
19948     }
19949   }
19950
19951   jresult = (void *)result;
19952   return jresult;
19953 }
19954
19955
19956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19957   void * jresult ;
19958   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19959   Dali::PropertyNotification *arg2 = 0 ;
19960   Dali::PropertyNotification *result = 0 ;
19961
19962   arg1 = (Dali::PropertyNotification *)jarg1;
19963   arg2 = (Dali::PropertyNotification *)jarg2;
19964   if (!arg2) {
19965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19966     return 0;
19967   }
19968   {
19969     try {
19970       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19971     } catch (std::out_of_range& e) {
19972       {
19973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19974       };
19975     } catch (std::exception& e) {
19976       {
19977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19978       };
19979     } catch (Dali::DaliException e) {
19980       {
19981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19982       };
19983     } catch (...) {
19984       {
19985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19986       };
19987     }
19988   }
19989
19990   jresult = (void *)result;
19991   return jresult;
19992 }
19993
19994
19995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
19996   void * jresult ;
19997   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19998   Dali::PropertyCondition result;
19999
20000   arg1 = (Dali::PropertyNotification *)jarg1;
20001   {
20002     try {
20003       result = (arg1)->GetCondition();
20004     } catch (std::out_of_range& e) {
20005       {
20006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20007       };
20008     } catch (std::exception& e) {
20009       {
20010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20011       };
20012     } catch (Dali::DaliException e) {
20013       {
20014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20015       };
20016     } catch (...) {
20017       {
20018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20019       };
20020     }
20021   }
20022
20023   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20024   return jresult;
20025 }
20026
20027
20028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20029   void * jresult ;
20030   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20031   Dali::Handle result;
20032
20033   arg1 = (Dali::PropertyNotification *)jarg1;
20034   {
20035     try {
20036       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20037     } catch (std::out_of_range& e) {
20038       {
20039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20040       };
20041     } catch (std::exception& e) {
20042       {
20043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20044       };
20045     } catch (Dali::DaliException e) {
20046       {
20047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20048       };
20049     } catch (...) {
20050       {
20051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20052       };
20053     }
20054   }
20055
20056   jresult = new Dali::Handle((const Dali::Handle &)result);
20057   return jresult;
20058 }
20059
20060
20061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20062   int jresult ;
20063   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20064   Dali::Property::Index result;
20065
20066   arg1 = (Dali::PropertyNotification *)jarg1;
20067   {
20068     try {
20069       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20070     } catch (std::out_of_range& e) {
20071       {
20072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20073       };
20074     } catch (std::exception& e) {
20075       {
20076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20077       };
20078     } catch (Dali::DaliException e) {
20079       {
20080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20081       };
20082     } catch (...) {
20083       {
20084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20085       };
20086     }
20087   }
20088
20089   jresult = result;
20090   return jresult;
20091 }
20092
20093
20094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20095   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20096   Dali::PropertyNotification::NotifyMode arg2 ;
20097
20098   arg1 = (Dali::PropertyNotification *)jarg1;
20099   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20100   {
20101     try {
20102       (arg1)->SetNotifyMode(arg2);
20103     } catch (std::out_of_range& e) {
20104       {
20105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20106       };
20107     } catch (std::exception& e) {
20108       {
20109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20110       };
20111     } catch (Dali::DaliException e) {
20112       {
20113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20114       };
20115     } catch (...) {
20116       {
20117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20118       };
20119     }
20120   }
20121
20122 }
20123
20124
20125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20126   int jresult ;
20127   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20128   Dali::PropertyNotification::NotifyMode result;
20129
20130   arg1 = (Dali::PropertyNotification *)jarg1;
20131   {
20132     try {
20133       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20134     } catch (std::out_of_range& e) {
20135       {
20136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20137       };
20138     } catch (std::exception& e) {
20139       {
20140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20141       };
20142     } catch (Dali::DaliException e) {
20143       {
20144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20145       };
20146     } catch (...) {
20147       {
20148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20149       };
20150     }
20151   }
20152
20153   jresult = (int)result;
20154   return jresult;
20155 }
20156
20157
20158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20159   unsigned int jresult ;
20160   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20161   bool result;
20162
20163   arg1 = (Dali::PropertyNotification *)jarg1;
20164   {
20165     try {
20166       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20167     } catch (std::out_of_range& e) {
20168       {
20169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20170       };
20171     } catch (std::exception& e) {
20172       {
20173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20174       };
20175     } catch (Dali::DaliException e) {
20176       {
20177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20178       };
20179     } catch (...) {
20180       {
20181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20182       };
20183     }
20184   }
20185
20186   jresult = result;
20187   return jresult;
20188 }
20189
20190
20191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20192   void * jresult ;
20193   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20194   Dali::PropertyNotifySignalType *result = 0 ;
20195
20196   arg1 = (Dali::PropertyNotification *)jarg1;
20197   {
20198     try {
20199       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20200     } catch (std::out_of_range& e) {
20201       {
20202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20203       };
20204     } catch (std::exception& e) {
20205       {
20206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20207       };
20208     } catch (Dali::DaliException e) {
20209       {
20210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20211       };
20212     } catch (...) {
20213       {
20214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20215       };
20216     }
20217   }
20218
20219   jresult = (void *)result;
20220   return jresult;
20221 }
20222
20223
20224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20225   void * jresult ;
20226   Dali::Handle *result = 0 ;
20227
20228   {
20229     try {
20230       result = (Dali::Handle *)new Dali::Handle();
20231     } catch (std::out_of_range& e) {
20232       {
20233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20234       };
20235     } catch (std::exception& e) {
20236       {
20237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20238       };
20239     } catch (Dali::DaliException e) {
20240       {
20241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20242       };
20243     } catch (...) {
20244       {
20245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20246       };
20247     }
20248   }
20249
20250   jresult = (void *)result;
20251   return jresult;
20252 }
20253
20254
20255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20256   void * jresult ;
20257   Dali::Handle result;
20258
20259   {
20260     try {
20261       result = Dali::Handle::New();
20262     } catch (std::out_of_range& e) {
20263       {
20264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20265       };
20266     } catch (std::exception& e) {
20267       {
20268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20269       };
20270     } catch (Dali::DaliException e) {
20271       {
20272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20273       };
20274     } catch (...) {
20275       {
20276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20277       };
20278     }
20279   }
20280
20281   jresult = new Dali::Handle((const Dali::Handle &)result);
20282   return jresult;
20283 }
20284
20285
20286 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20287   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20288
20289   arg1 = (Dali::Handle *)jarg1;
20290   {
20291     try {
20292       delete arg1;
20293     } catch (std::out_of_range& e) {
20294       {
20295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20296       };
20297     } catch (std::exception& e) {
20298       {
20299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20300       };
20301     } catch (Dali::DaliException e) {
20302       {
20303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20304       };
20305     } catch (...) {
20306       {
20307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20308       };
20309     }
20310   }
20311
20312 }
20313
20314
20315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20316   void * jresult ;
20317   Dali::Handle *arg1 = 0 ;
20318   Dali::Handle *result = 0 ;
20319
20320   arg1 = (Dali::Handle *)jarg1;
20321   if (!arg1) {
20322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20323     return 0;
20324   }
20325   {
20326     try {
20327       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20328     } catch (std::out_of_range& e) {
20329       {
20330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20331       };
20332     } catch (std::exception& e) {
20333       {
20334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20335       };
20336     } catch (Dali::DaliException e) {
20337       {
20338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20339       };
20340     } catch (...) {
20341       {
20342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20343       };
20344     }
20345   }
20346
20347   jresult = (void *)result;
20348   return jresult;
20349 }
20350
20351
20352 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20353   void * jresult ;
20354   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20355   Dali::Handle *arg2 = 0 ;
20356   Dali::Handle *result = 0 ;
20357
20358   arg1 = (Dali::Handle *)jarg1;
20359   arg2 = (Dali::Handle *)jarg2;
20360   if (!arg2) {
20361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20362     return 0;
20363   }
20364   {
20365     try {
20366       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20367     } catch (std::out_of_range& e) {
20368       {
20369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20370       };
20371     } catch (std::exception& e) {
20372       {
20373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20374       };
20375     } catch (Dali::DaliException e) {
20376       {
20377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20378       };
20379     } catch (...) {
20380       {
20381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20382       };
20383     }
20384   }
20385
20386   jresult = (void *)result;
20387   return jresult;
20388 }
20389
20390
20391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20392   void * jresult ;
20393   Dali::BaseHandle arg1 ;
20394   Dali::BaseHandle *argp1 ;
20395   Dali::Handle result;
20396
20397   argp1 = (Dali::BaseHandle *)jarg1;
20398   if (!argp1) {
20399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20400     return 0;
20401   }
20402   arg1 = *argp1;
20403   {
20404     try {
20405       result = Dali::Handle::DownCast(arg1);
20406     } catch (std::out_of_range& e) {
20407       {
20408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20409       };
20410     } catch (std::exception& e) {
20411       {
20412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20413       };
20414     } catch (Dali::DaliException e) {
20415       {
20416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20417       };
20418     } catch (...) {
20419       {
20420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20421       };
20422     }
20423   }
20424
20425   jresult = new Dali::Handle((const Dali::Handle &)result);
20426   return jresult;
20427 }
20428
20429
20430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20431   unsigned int jresult ;
20432   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20433   Dali::Handle::Capability arg2 ;
20434   bool result;
20435
20436   arg1 = (Dali::Handle *)jarg1;
20437   arg2 = (Dali::Handle::Capability)jarg2;
20438   {
20439     try {
20440       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20441     } catch (std::out_of_range& e) {
20442       {
20443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20444       };
20445     } catch (std::exception& e) {
20446       {
20447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20448       };
20449     } catch (Dali::DaliException e) {
20450       {
20451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20452       };
20453     } catch (...) {
20454       {
20455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20456       };
20457     }
20458   }
20459
20460   jresult = result;
20461   return jresult;
20462 }
20463
20464
20465 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20466   unsigned int jresult ;
20467   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20468   unsigned int result;
20469
20470   arg1 = (Dali::Handle *)jarg1;
20471   {
20472     try {
20473       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20474     } catch (std::out_of_range& e) {
20475       {
20476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20477       };
20478     } catch (std::exception& e) {
20479       {
20480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20481       };
20482     } catch (Dali::DaliException e) {
20483       {
20484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20485       };
20486     } catch (...) {
20487       {
20488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20489       };
20490     }
20491   }
20492
20493   jresult = result;
20494   return jresult;
20495 }
20496
20497
20498 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20499   char * jresult ;
20500   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20501   Dali::Property::Index arg2 ;
20502   std::string result;
20503
20504   arg1 = (Dali::Handle *)jarg1;
20505   arg2 = (Dali::Property::Index)jarg2;
20506   {
20507     try {
20508       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20509     } catch (std::out_of_range& e) {
20510       {
20511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20512       };
20513     } catch (std::exception& e) {
20514       {
20515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20516       };
20517     } catch (Dali::DaliException e) {
20518       {
20519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20520       };
20521     } catch (...) {
20522       {
20523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20524       };
20525     }
20526   }
20527
20528   jresult = SWIG_csharp_string_callback((&result)->c_str());
20529   return jresult;
20530 }
20531
20532
20533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20534   int jresult ;
20535   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20536   std::string *arg2 = 0 ;
20537   Dali::Property::Index result;
20538
20539   arg1 = (Dali::Handle *)jarg1;
20540   if (!jarg2) {
20541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20542     return 0;
20543   }
20544   std::string arg2_str(jarg2);
20545   arg2 = &arg2_str;
20546   {
20547     try {
20548       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20549     } catch (std::out_of_range& e) {
20550       {
20551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20552       };
20553     } catch (std::exception& e) {
20554       {
20555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20556       };
20557     } catch (Dali::DaliException e) {
20558       {
20559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20560       };
20561     } catch (...) {
20562       {
20563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20564       };
20565     }
20566   }
20567
20568   jresult = result;
20569
20570   //argout typemap for const std::string&
20571
20572   return jresult;
20573 }
20574
20575
20576 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20577   unsigned int jresult ;
20578   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20579   Dali::Property::Index arg2 ;
20580   bool result;
20581
20582   arg1 = (Dali::Handle *)jarg1;
20583   arg2 = (Dali::Property::Index)jarg2;
20584   {
20585     try {
20586       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20587     } catch (std::out_of_range& e) {
20588       {
20589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20590       };
20591     } catch (std::exception& e) {
20592       {
20593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20594       };
20595     } catch (Dali::DaliException e) {
20596       {
20597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20598       };
20599     } catch (...) {
20600       {
20601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20602       };
20603     }
20604   }
20605
20606   jresult = result;
20607   return jresult;
20608 }
20609
20610
20611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20612   unsigned int jresult ;
20613   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20614   Dali::Property::Index arg2 ;
20615   bool result;
20616
20617   arg1 = (Dali::Handle *)jarg1;
20618   arg2 = (Dali::Property::Index)jarg2;
20619   {
20620     try {
20621       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20622     } catch (std::out_of_range& e) {
20623       {
20624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20625       };
20626     } catch (std::exception& e) {
20627       {
20628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20629       };
20630     } catch (Dali::DaliException e) {
20631       {
20632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20633       };
20634     } catch (...) {
20635       {
20636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20637       };
20638     }
20639   }
20640
20641   jresult = result;
20642   return jresult;
20643 }
20644
20645
20646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20647   unsigned int jresult ;
20648   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20649   Dali::Property::Index arg2 ;
20650   bool result;
20651
20652   arg1 = (Dali::Handle *)jarg1;
20653   arg2 = (Dali::Property::Index)jarg2;
20654   {
20655     try {
20656       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20657     } catch (std::out_of_range& e) {
20658       {
20659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20660       };
20661     } catch (std::exception& e) {
20662       {
20663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20664       };
20665     } catch (Dali::DaliException e) {
20666       {
20667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20668       };
20669     } catch (...) {
20670       {
20671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20672       };
20673     }
20674   }
20675
20676   jresult = result;
20677   return jresult;
20678 }
20679
20680
20681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20682   int jresult ;
20683   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20684   Dali::Property::Index arg2 ;
20685   Dali::Property::Type result;
20686
20687   arg1 = (Dali::Handle *)jarg1;
20688   arg2 = (Dali::Property::Index)jarg2;
20689   {
20690     try {
20691       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20692     } catch (std::out_of_range& e) {
20693       {
20694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20695       };
20696     } catch (std::exception& e) {
20697       {
20698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20699       };
20700     } catch (Dali::DaliException e) {
20701       {
20702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20703       };
20704     } catch (...) {
20705       {
20706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20707       };
20708     }
20709   }
20710
20711   jresult = (int)result;
20712   return jresult;
20713 }
20714
20715
20716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20717   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20718   Dali::Property::Index arg2 ;
20719   Dali::Property::Value *arg3 = 0 ;
20720
20721   arg1 = (Dali::Handle *)jarg1;
20722   arg2 = (Dali::Property::Index)jarg2;
20723   arg3 = (Dali::Property::Value *)jarg3;
20724   if (!arg3) {
20725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20726     return ;
20727   }
20728   {
20729     try {
20730       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20731     } catch (std::out_of_range& e) {
20732       {
20733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20734       };
20735     } catch (std::exception& e) {
20736       {
20737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20738       };
20739     } catch (Dali::DaliException e) {
20740       {
20741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20742       };
20743     } catch (...) {
20744       {
20745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20746       };
20747     }
20748   }
20749
20750 }
20751
20752
20753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20754   int jresult ;
20755   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20756   std::string *arg2 = 0 ;
20757   Dali::Property::Value *arg3 = 0 ;
20758   Dali::Property::Index result;
20759
20760   arg1 = (Dali::Handle *)jarg1;
20761   if (!jarg2) {
20762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20763     return 0;
20764   }
20765   std::string arg2_str(jarg2);
20766   arg2 = &arg2_str;
20767   arg3 = (Dali::Property::Value *)jarg3;
20768   if (!arg3) {
20769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20770     return 0;
20771   }
20772   {
20773     try {
20774       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20775     } catch (std::out_of_range& e) {
20776       {
20777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20778       };
20779     } catch (std::exception& e) {
20780       {
20781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20782       };
20783     } catch (Dali::DaliException e) {
20784       {
20785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20786       };
20787     } catch (...) {
20788       {
20789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20790       };
20791     }
20792   }
20793
20794   jresult = result;
20795
20796   //argout typemap for const std::string&
20797
20798   return jresult;
20799 }
20800
20801
20802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20803   int jresult ;
20804   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20805   std::string *arg2 = 0 ;
20806   Dali::Property::Value *arg3 = 0 ;
20807   Dali::Property::AccessMode arg4 ;
20808   Dali::Property::Index result;
20809
20810   arg1 = (Dali::Handle *)jarg1;
20811   if (!jarg2) {
20812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20813     return 0;
20814   }
20815   std::string arg2_str(jarg2);
20816   arg2 = &arg2_str;
20817   arg3 = (Dali::Property::Value *)jarg3;
20818   if (!arg3) {
20819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20820     return 0;
20821   }
20822   arg4 = (Dali::Property::AccessMode)jarg4;
20823   {
20824     try {
20825       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20826     } catch (std::out_of_range& e) {
20827       {
20828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20829       };
20830     } catch (std::exception& e) {
20831       {
20832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20833       };
20834     } catch (Dali::DaliException e) {
20835       {
20836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20837       };
20838     } catch (...) {
20839       {
20840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20841       };
20842     }
20843   }
20844
20845   jresult = result;
20846
20847   //argout typemap for const std::string&
20848
20849   return jresult;
20850 }
20851
20852
20853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20854   void * jresult ;
20855   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20856   Dali::Property::Index arg2 ;
20857   Dali::Property::Value result;
20858
20859   arg1 = (Dali::Handle *)jarg1;
20860   arg2 = (Dali::Property::Index)jarg2;
20861   {
20862     try {
20863       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20864     } catch (std::out_of_range& e) {
20865       {
20866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20867       };
20868     } catch (std::exception& e) {
20869       {
20870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20871       };
20872     } catch (Dali::DaliException e) {
20873       {
20874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20875       };
20876     } catch (...) {
20877       {
20878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20879       };
20880     }
20881   }
20882
20883   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20884   return jresult;
20885 }
20886
20887
20888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20889   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20890   Dali::Property::IndexContainer *arg2 = 0 ;
20891
20892   arg1 = (Dali::Handle *)jarg1;
20893   arg2 = (Dali::Property::IndexContainer *)jarg2;
20894   if (!arg2) {
20895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20896     return ;
20897   }
20898   {
20899     try {
20900       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20901     } catch (std::out_of_range& e) {
20902       {
20903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20904       };
20905     } catch (std::exception& e) {
20906       {
20907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20908       };
20909     } catch (Dali::DaliException e) {
20910       {
20911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20912       };
20913     } catch (...) {
20914       {
20915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20916       };
20917     }
20918   }
20919
20920 }
20921
20922
20923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20924   void * jresult ;
20925   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20926   Dali::Property::Index arg2 ;
20927   Dali::PropertyCondition *arg3 = 0 ;
20928   Dali::PropertyNotification result;
20929
20930   arg1 = (Dali::Handle *)jarg1;
20931   arg2 = (Dali::Property::Index)jarg2;
20932   arg3 = (Dali::PropertyCondition *)jarg3;
20933   if (!arg3) {
20934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20935     return 0;
20936   }
20937   {
20938     try {
20939       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20940     } catch (std::out_of_range& e) {
20941       {
20942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20943       };
20944     } catch (std::exception& e) {
20945       {
20946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20947       };
20948     } catch (Dali::DaliException e) {
20949       {
20950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20951       };
20952     } catch (...) {
20953       {
20954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20955       };
20956     }
20957   }
20958
20959   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20960   return jresult;
20961 }
20962
20963
20964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20965   void * jresult ;
20966   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20967   Dali::Property::Index arg2 ;
20968   int arg3 ;
20969   Dali::PropertyCondition *arg4 = 0 ;
20970   Dali::PropertyNotification result;
20971
20972   arg1 = (Dali::Handle *)jarg1;
20973   arg2 = (Dali::Property::Index)jarg2;
20974   arg3 = (int)jarg3;
20975   arg4 = (Dali::PropertyCondition *)jarg4;
20976   if (!arg4) {
20977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20978     return 0;
20979   }
20980   {
20981     try {
20982       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
20983     } catch (std::out_of_range& e) {
20984       {
20985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20986       };
20987     } catch (std::exception& e) {
20988       {
20989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20990       };
20991     } catch (Dali::DaliException e) {
20992       {
20993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20994       };
20995     } catch (...) {
20996       {
20997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20998       };
20999     }
21000   }
21001
21002   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21003   return jresult;
21004 }
21005
21006
21007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21008   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21009   Dali::PropertyNotification arg2 ;
21010   Dali::PropertyNotification *argp2 ;
21011
21012   arg1 = (Dali::Handle *)jarg1;
21013   argp2 = (Dali::PropertyNotification *)jarg2;
21014   if (!argp2) {
21015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21016     return ;
21017   }
21018   arg2 = *argp2;
21019   {
21020     try {
21021       (arg1)->RemovePropertyNotification(arg2);
21022     } catch (std::out_of_range& e) {
21023       {
21024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21025       };
21026     } catch (std::exception& e) {
21027       {
21028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21029       };
21030     } catch (Dali::DaliException e) {
21031       {
21032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21033       };
21034     } catch (...) {
21035       {
21036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21037       };
21038     }
21039   }
21040
21041 }
21042
21043
21044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21045   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21046
21047   arg1 = (Dali::Handle *)jarg1;
21048   {
21049     try {
21050       (arg1)->RemovePropertyNotifications();
21051     } catch (std::out_of_range& e) {
21052       {
21053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21054       };
21055     } catch (std::exception& e) {
21056       {
21057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21058       };
21059     } catch (Dali::DaliException e) {
21060       {
21061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21062       };
21063     } catch (...) {
21064       {
21065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21066       };
21067     }
21068   }
21069
21070 }
21071
21072
21073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21074   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21075
21076   arg1 = (Dali::Handle *)jarg1;
21077   {
21078     try {
21079       (arg1)->RemoveConstraints();
21080     } catch (std::out_of_range& e) {
21081       {
21082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21083       };
21084     } catch (std::exception& e) {
21085       {
21086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21087       };
21088     } catch (Dali::DaliException e) {
21089       {
21090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21091       };
21092     } catch (...) {
21093       {
21094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21095       };
21096     }
21097   }
21098
21099 }
21100
21101
21102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21103   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21104   unsigned int arg2 ;
21105
21106   arg1 = (Dali::Handle *)jarg1;
21107   arg2 = (unsigned int)jarg2;
21108   {
21109     try {
21110       (arg1)->RemoveConstraints(arg2);
21111     } catch (std::out_of_range& e) {
21112       {
21113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21114       };
21115     } catch (std::exception& e) {
21116       {
21117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21118       };
21119     } catch (Dali::DaliException e) {
21120       {
21121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21122       };
21123     } catch (...) {
21124       {
21125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21126       };
21127     }
21128   }
21129
21130 }
21131
21132
21133 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21134   int jresult ;
21135   Dali::Property::Index result;
21136
21137   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21138   jresult = result;
21139   return jresult;
21140 }
21141
21142
21143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21144   void * jresult ;
21145   Dali::Handle result;
21146
21147   {
21148     try {
21149       result = Dali::WeightObject::New();
21150     } catch (std::out_of_range& e) {
21151       {
21152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21153       };
21154     } catch (std::exception& e) {
21155       {
21156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21157       };
21158     } catch (Dali::DaliException e) {
21159       {
21160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21161       };
21162     } catch (...) {
21163       {
21164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21165       };
21166     }
21167   }
21168
21169   jresult = new Dali::Handle((const Dali::Handle &)result);
21170   return jresult;
21171 }
21172
21173
21174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21175   void * jresult ;
21176   Dali::TypeInfo *result = 0 ;
21177
21178   {
21179     try {
21180       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21181     } catch (std::out_of_range& e) {
21182       {
21183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21184       };
21185     } catch (std::exception& e) {
21186       {
21187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21188       };
21189     } catch (Dali::DaliException e) {
21190       {
21191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21192       };
21193     } catch (...) {
21194       {
21195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21196       };
21197     }
21198   }
21199
21200   jresult = (void *)result;
21201   return jresult;
21202 }
21203
21204
21205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21206   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21207
21208   arg1 = (Dali::TypeInfo *)jarg1;
21209   {
21210     try {
21211       delete arg1;
21212     } catch (std::out_of_range& e) {
21213       {
21214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21215       };
21216     } catch (std::exception& e) {
21217       {
21218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21219       };
21220     } catch (Dali::DaliException e) {
21221       {
21222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21223       };
21224     } catch (...) {
21225       {
21226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21227       };
21228     }
21229   }
21230
21231 }
21232
21233
21234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21235   void * jresult ;
21236   Dali::TypeInfo *arg1 = 0 ;
21237   Dali::TypeInfo *result = 0 ;
21238
21239   arg1 = (Dali::TypeInfo *)jarg1;
21240   if (!arg1) {
21241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21242     return 0;
21243   }
21244   {
21245     try {
21246       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21247     } catch (std::out_of_range& e) {
21248       {
21249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21250       };
21251     } catch (std::exception& e) {
21252       {
21253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21254       };
21255     } catch (Dali::DaliException e) {
21256       {
21257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21258       };
21259     } catch (...) {
21260       {
21261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21262       };
21263     }
21264   }
21265
21266   jresult = (void *)result;
21267   return jresult;
21268 }
21269
21270
21271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21272   void * jresult ;
21273   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21274   Dali::TypeInfo *arg2 = 0 ;
21275   Dali::TypeInfo *result = 0 ;
21276
21277   arg1 = (Dali::TypeInfo *)jarg1;
21278   arg2 = (Dali::TypeInfo *)jarg2;
21279   if (!arg2) {
21280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21281     return 0;
21282   }
21283   {
21284     try {
21285       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21286     } catch (std::out_of_range& e) {
21287       {
21288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21289       };
21290     } catch (std::exception& e) {
21291       {
21292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21293       };
21294     } catch (Dali::DaliException e) {
21295       {
21296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21297       };
21298     } catch (...) {
21299       {
21300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21301       };
21302     }
21303   }
21304
21305   jresult = (void *)result;
21306   return jresult;
21307 }
21308
21309
21310 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21311   char * jresult ;
21312   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21313   std::string *result = 0 ;
21314
21315   arg1 = (Dali::TypeInfo *)jarg1;
21316   {
21317     try {
21318       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21319     } catch (std::out_of_range& e) {
21320       {
21321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21322       };
21323     } catch (std::exception& e) {
21324       {
21325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21326       };
21327     } catch (Dali::DaliException e) {
21328       {
21329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21330       };
21331     } catch (...) {
21332       {
21333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21334       };
21335     }
21336   }
21337
21338   jresult = SWIG_csharp_string_callback(result->c_str());
21339   return jresult;
21340 }
21341
21342
21343 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21344   char * jresult ;
21345   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21346   std::string *result = 0 ;
21347
21348   arg1 = (Dali::TypeInfo *)jarg1;
21349   {
21350     try {
21351       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21352     } catch (std::out_of_range& e) {
21353       {
21354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21355       };
21356     } catch (std::exception& e) {
21357       {
21358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21359       };
21360     } catch (Dali::DaliException e) {
21361       {
21362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21363       };
21364     } catch (...) {
21365       {
21366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21367       };
21368     }
21369   }
21370
21371   jresult = SWIG_csharp_string_callback(result->c_str());
21372   return jresult;
21373 }
21374
21375
21376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21377   void * jresult ;
21378   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21379   Dali::BaseHandle result;
21380
21381   arg1 = (Dali::TypeInfo *)jarg1;
21382   {
21383     try {
21384       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21385     } catch (std::out_of_range& e) {
21386       {
21387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21388       };
21389     } catch (std::exception& e) {
21390       {
21391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21392       };
21393     } catch (Dali::DaliException e) {
21394       {
21395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21396       };
21397     } catch (...) {
21398       {
21399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21400       };
21401     }
21402   }
21403
21404   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21405   return jresult;
21406 }
21407
21408
21409 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21410   unsigned long jresult ;
21411   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21412   size_t result;
21413
21414   arg1 = (Dali::TypeInfo *)jarg1;
21415   {
21416     try {
21417       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21418     } catch (std::out_of_range& e) {
21419       {
21420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21421       };
21422     } catch (std::exception& e) {
21423       {
21424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21425       };
21426     } catch (Dali::DaliException e) {
21427       {
21428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21429       };
21430     } catch (...) {
21431       {
21432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21433       };
21434     }
21435   }
21436
21437   jresult = (unsigned long)result;
21438   return jresult;
21439 }
21440
21441
21442 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21443   char * jresult ;
21444   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21445   size_t arg2 ;
21446   std::string result;
21447
21448   arg1 = (Dali::TypeInfo *)jarg1;
21449   arg2 = (size_t)jarg2;
21450   {
21451     try {
21452       result = (arg1)->GetActionName(arg2);
21453     } catch (std::out_of_range& e) {
21454       {
21455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21456       };
21457     } catch (std::exception& e) {
21458       {
21459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21460       };
21461     } catch (Dali::DaliException e) {
21462       {
21463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21464       };
21465     } catch (...) {
21466       {
21467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21468       };
21469     }
21470   }
21471
21472   jresult = SWIG_csharp_string_callback((&result)->c_str());
21473   return jresult;
21474 }
21475
21476
21477 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21478   unsigned long jresult ;
21479   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21480   size_t result;
21481
21482   arg1 = (Dali::TypeInfo *)jarg1;
21483   {
21484     try {
21485       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21486     } catch (std::out_of_range& e) {
21487       {
21488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21489       };
21490     } catch (std::exception& e) {
21491       {
21492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21493       };
21494     } catch (Dali::DaliException e) {
21495       {
21496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21497       };
21498     } catch (...) {
21499       {
21500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21501       };
21502     }
21503   }
21504
21505   jresult = (unsigned long)result;
21506   return jresult;
21507 }
21508
21509
21510 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21511   char * jresult ;
21512   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21513   size_t arg2 ;
21514   std::string result;
21515
21516   arg1 = (Dali::TypeInfo *)jarg1;
21517   arg2 = (size_t)jarg2;
21518   {
21519     try {
21520       result = (arg1)->GetSignalName(arg2);
21521     } catch (std::out_of_range& e) {
21522       {
21523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21524       };
21525     } catch (std::exception& e) {
21526       {
21527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21528       };
21529     } catch (Dali::DaliException e) {
21530       {
21531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21532       };
21533     } catch (...) {
21534       {
21535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21536       };
21537     }
21538   }
21539
21540   jresult = SWIG_csharp_string_callback((&result)->c_str());
21541   return jresult;
21542 }
21543
21544
21545 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21546   unsigned long jresult ;
21547   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21548   size_t result;
21549
21550   arg1 = (Dali::TypeInfo *)jarg1;
21551   {
21552     try {
21553       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21554     } catch (std::out_of_range& e) {
21555       {
21556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21557       };
21558     } catch (std::exception& e) {
21559       {
21560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21561       };
21562     } catch (Dali::DaliException e) {
21563       {
21564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21565       };
21566     } catch (...) {
21567       {
21568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21569       };
21570     }
21571   }
21572
21573   jresult = (unsigned long)result;
21574   return jresult;
21575 }
21576
21577
21578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21579   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21580   Dali::Property::IndexContainer *arg2 = 0 ;
21581
21582   arg1 = (Dali::TypeInfo *)jarg1;
21583   arg2 = (Dali::Property::IndexContainer *)jarg2;
21584   if (!arg2) {
21585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21586     return ;
21587   }
21588   {
21589     try {
21590       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21591     } catch (std::out_of_range& e) {
21592       {
21593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21594       };
21595     } catch (std::exception& e) {
21596       {
21597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21598       };
21599     } catch (Dali::DaliException e) {
21600       {
21601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21602       };
21603     } catch (...) {
21604       {
21605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21606       };
21607     }
21608   }
21609
21610 }
21611
21612
21613 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21614   char * jresult ;
21615   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21616   Dali::Property::Index arg2 ;
21617   std::string *result = 0 ;
21618
21619   arg1 = (Dali::TypeInfo *)jarg1;
21620   arg2 = (Dali::Property::Index)jarg2;
21621   {
21622     try {
21623       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21624     } catch (std::out_of_range& e) {
21625       {
21626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21627       };
21628     } catch (std::exception& e) {
21629       {
21630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21631       };
21632     } catch (Dali::DaliException e) {
21633       {
21634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21635       };
21636     } catch (...) {
21637       {
21638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21639       };
21640     }
21641   }
21642
21643   jresult = SWIG_csharp_string_callback(result->c_str());
21644   return jresult;
21645 }
21646
21647
21648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21649   void * jresult ;
21650   Dali::TypeRegistry result;
21651
21652   {
21653     try {
21654       result = Dali::TypeRegistry::Get();
21655     } catch (std::out_of_range& e) {
21656       {
21657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21658       };
21659     } catch (std::exception& e) {
21660       {
21661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21662       };
21663     } catch (Dali::DaliException e) {
21664       {
21665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21666       };
21667     } catch (...) {
21668       {
21669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21670       };
21671     }
21672   }
21673
21674   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21675   return jresult;
21676 }
21677
21678
21679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21680   void * jresult ;
21681   Dali::TypeRegistry *result = 0 ;
21682
21683   {
21684     try {
21685       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21686     } catch (std::out_of_range& e) {
21687       {
21688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21689       };
21690     } catch (std::exception& e) {
21691       {
21692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21693       };
21694     } catch (Dali::DaliException e) {
21695       {
21696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21697       };
21698     } catch (...) {
21699       {
21700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21701       };
21702     }
21703   }
21704
21705   jresult = (void *)result;
21706   return jresult;
21707 }
21708
21709
21710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21711   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21712
21713   arg1 = (Dali::TypeRegistry *)jarg1;
21714   {
21715     try {
21716       delete arg1;
21717     } catch (std::out_of_range& e) {
21718       {
21719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21720       };
21721     } catch (std::exception& e) {
21722       {
21723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21724       };
21725     } catch (Dali::DaliException e) {
21726       {
21727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21728       };
21729     } catch (...) {
21730       {
21731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21732       };
21733     }
21734   }
21735
21736 }
21737
21738
21739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21740   void * jresult ;
21741   Dali::TypeRegistry *arg1 = 0 ;
21742   Dali::TypeRegistry *result = 0 ;
21743
21744   arg1 = (Dali::TypeRegistry *)jarg1;
21745   if (!arg1) {
21746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21747     return 0;
21748   }
21749   {
21750     try {
21751       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21752     } catch (std::out_of_range& e) {
21753       {
21754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21755       };
21756     } catch (std::exception& e) {
21757       {
21758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21759       };
21760     } catch (Dali::DaliException e) {
21761       {
21762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21763       };
21764     } catch (...) {
21765       {
21766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21767       };
21768     }
21769   }
21770
21771   jresult = (void *)result;
21772   return jresult;
21773 }
21774
21775
21776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21777   void * jresult ;
21778   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21779   Dali::TypeRegistry *arg2 = 0 ;
21780   Dali::TypeRegistry *result = 0 ;
21781
21782   arg1 = (Dali::TypeRegistry *)jarg1;
21783   arg2 = (Dali::TypeRegistry *)jarg2;
21784   if (!arg2) {
21785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21786     return 0;
21787   }
21788   {
21789     try {
21790       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21791     } catch (std::out_of_range& e) {
21792       {
21793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21794       };
21795     } catch (std::exception& e) {
21796       {
21797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21798       };
21799     } catch (Dali::DaliException e) {
21800       {
21801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21802       };
21803     } catch (...) {
21804       {
21805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21806       };
21807     }
21808   }
21809
21810   jresult = (void *)result;
21811   return jresult;
21812 }
21813
21814
21815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21816   void * jresult ;
21817   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21818   std::string *arg2 = 0 ;
21819   Dali::TypeInfo result;
21820
21821   arg1 = (Dali::TypeRegistry *)jarg1;
21822   if (!jarg2) {
21823     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21824     return 0;
21825   }
21826   std::string arg2_str(jarg2);
21827   arg2 = &arg2_str;
21828   {
21829     try {
21830       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21831     } catch (std::out_of_range& e) {
21832       {
21833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21834       };
21835     } catch (std::exception& e) {
21836       {
21837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21838       };
21839     } catch (Dali::DaliException e) {
21840       {
21841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21842       };
21843     } catch (...) {
21844       {
21845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21846       };
21847     }
21848   }
21849
21850   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21851
21852   //argout typemap for const std::string&
21853
21854   return jresult;
21855 }
21856
21857
21858 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21859   void * jresult ;
21860   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21861   std::type_info *arg2 = 0 ;
21862   Dali::TypeInfo result;
21863
21864   arg1 = (Dali::TypeRegistry *)jarg1;
21865   arg2 = (std::type_info *)jarg2;
21866   if (!arg2) {
21867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21868     return 0;
21869   }
21870   {
21871     try {
21872       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21873     } catch (std::out_of_range& e) {
21874       {
21875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21876       };
21877     } catch (std::exception& e) {
21878       {
21879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21880       };
21881     } catch (Dali::DaliException e) {
21882       {
21883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21884       };
21885     } catch (...) {
21886       {
21887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21888       };
21889     }
21890   }
21891
21892   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21893   return jresult;
21894 }
21895
21896
21897 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21898   unsigned long jresult ;
21899   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21900   size_t result;
21901
21902   arg1 = (Dali::TypeRegistry *)jarg1;
21903   {
21904     try {
21905       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21906     } catch (std::out_of_range& e) {
21907       {
21908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21909       };
21910     } catch (std::exception& e) {
21911       {
21912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21913       };
21914     } catch (Dali::DaliException e) {
21915       {
21916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21917       };
21918     } catch (...) {
21919       {
21920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21921       };
21922     }
21923   }
21924
21925   jresult = (unsigned long)result;
21926   return jresult;
21927 }
21928
21929
21930 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21931   char * jresult ;
21932   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21933   size_t arg2 ;
21934   std::string result;
21935
21936   arg1 = (Dali::TypeRegistry *)jarg1;
21937   arg2 = (size_t)jarg2;
21938   {
21939     try {
21940       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21941     } catch (std::out_of_range& e) {
21942       {
21943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21944       };
21945     } catch (std::exception& e) {
21946       {
21947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21948       };
21949     } catch (Dali::DaliException e) {
21950       {
21951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21952       };
21953     } catch (...) {
21954       {
21955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21956       };
21957     }
21958   }
21959
21960   jresult = SWIG_csharp_string_callback((&result)->c_str());
21961   return jresult;
21962 }
21963
21964
21965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21966   void * jresult ;
21967   std::type_info *arg1 = 0 ;
21968   std::type_info *arg2 = 0 ;
21969   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21970   Dali::TypeRegistration *result = 0 ;
21971
21972   arg1 = (std::type_info *)jarg1;
21973   if (!arg1) {
21974     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21975     return 0;
21976   }
21977   arg2 = (std::type_info *)jarg2;
21978   if (!arg2) {
21979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21980     return 0;
21981   }
21982   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
21983   {
21984     try {
21985       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
21986     } catch (std::out_of_range& e) {
21987       {
21988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21989       };
21990     } catch (std::exception& e) {
21991       {
21992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21993       };
21994     } catch (Dali::DaliException e) {
21995       {
21996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21997       };
21998     } catch (...) {
21999       {
22000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22001       };
22002     }
22003   }
22004
22005   jresult = (void *)result;
22006   return jresult;
22007 }
22008
22009
22010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22011   void * jresult ;
22012   std::type_info *arg1 = 0 ;
22013   std::type_info *arg2 = 0 ;
22014   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22015   bool arg4 ;
22016   Dali::TypeRegistration *result = 0 ;
22017
22018   arg1 = (std::type_info *)jarg1;
22019   if (!arg1) {
22020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22021     return 0;
22022   }
22023   arg2 = (std::type_info *)jarg2;
22024   if (!arg2) {
22025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22026     return 0;
22027   }
22028   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22029   arg4 = jarg4 ? true : false;
22030   {
22031     try {
22032       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22033     } catch (std::out_of_range& e) {
22034       {
22035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22036       };
22037     } catch (std::exception& e) {
22038       {
22039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22040       };
22041     } catch (Dali::DaliException e) {
22042       {
22043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22044       };
22045     } catch (...) {
22046       {
22047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22048       };
22049     }
22050   }
22051
22052   jresult = (void *)result;
22053   return jresult;
22054 }
22055
22056
22057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22058   void * jresult ;
22059   std::string *arg1 = 0 ;
22060   std::type_info *arg2 = 0 ;
22061   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22062   Dali::TypeRegistration *result = 0 ;
22063
22064   if (!jarg1) {
22065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22066     return 0;
22067   }
22068   std::string arg1_str(jarg1);
22069   arg1 = &arg1_str;
22070   arg2 = (std::type_info *)jarg2;
22071   if (!arg2) {
22072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22073     return 0;
22074   }
22075   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22076   {
22077     try {
22078       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22079     } catch (std::out_of_range& e) {
22080       {
22081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22082       };
22083     } catch (std::exception& e) {
22084       {
22085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22086       };
22087     } catch (Dali::DaliException e) {
22088       {
22089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22090       };
22091     } catch (...) {
22092       {
22093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22094       };
22095     }
22096   }
22097
22098   jresult = (void *)result;
22099
22100   //argout typemap for const std::string&
22101
22102   return jresult;
22103 }
22104
22105
22106 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22107   char * jresult ;
22108   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22109   std::string result;
22110
22111   arg1 = (Dali::TypeRegistration *)jarg1;
22112   {
22113     try {
22114       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22115     } catch (std::out_of_range& e) {
22116       {
22117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22118       };
22119     } catch (std::exception& e) {
22120       {
22121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22122       };
22123     } catch (Dali::DaliException e) {
22124       {
22125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22126       };
22127     } catch (...) {
22128       {
22129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22130       };
22131     }
22132   }
22133
22134   jresult = SWIG_csharp_string_callback((&result)->c_str());
22135   return jresult;
22136 }
22137
22138
22139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22140   std::string *arg1 = 0 ;
22141   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22142
22143   if (!jarg1) {
22144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22145     return ;
22146   }
22147   std::string arg1_str(jarg1);
22148   arg1 = &arg1_str;
22149   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22150   {
22151     try {
22152       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22153     } catch (std::out_of_range& e) {
22154       {
22155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22156       };
22157     } catch (std::exception& e) {
22158       {
22159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22160       };
22161     } catch (Dali::DaliException e) {
22162       {
22163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22164       };
22165     } catch (...) {
22166       {
22167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22168       };
22169     }
22170   }
22171
22172
22173   //argout typemap for const std::string&
22174
22175 }
22176
22177
22178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22179   std::string *arg1 = 0 ;
22180   std::string *arg2 = 0 ;
22181   int arg3 ;
22182   Dali::Property::Type arg4 ;
22183   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22184   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22185
22186   if (!jarg1) {
22187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22188     return ;
22189   }
22190   std::string arg1_str(jarg1);
22191   arg1 = &arg1_str;
22192   if (!jarg2) {
22193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22194     return ;
22195   }
22196   std::string arg2_str(jarg2);
22197   arg2 = &arg2_str;
22198   arg3 = (int)jarg3;
22199   arg4 = (Dali::Property::Type)jarg4;
22200   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22201   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22202   {
22203     try {
22204       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22205     } catch (std::out_of_range& e) {
22206       {
22207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22208       };
22209     } catch (std::exception& e) {
22210       {
22211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22212       };
22213     } catch (Dali::DaliException e) {
22214       {
22215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22216       };
22217     } catch (...) {
22218       {
22219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22220       };
22221     }
22222   }
22223
22224
22225   //argout typemap for const std::string&
22226
22227
22228   //argout typemap for const std::string&
22229
22230 }
22231
22232
22233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22234   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22235
22236   arg1 = (Dali::TypeRegistration *)jarg1;
22237   {
22238     try {
22239       delete arg1;
22240     } catch (std::out_of_range& e) {
22241       {
22242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22243       };
22244     } catch (std::exception& e) {
22245       {
22246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22247       };
22248     } catch (Dali::DaliException e) {
22249       {
22250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22251       };
22252     } catch (...) {
22253       {
22254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22255       };
22256     }
22257   }
22258
22259 }
22260
22261
22262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22263   void * jresult ;
22264   Dali::TypeRegistration *arg1 = 0 ;
22265   std::string *arg2 = 0 ;
22266   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22267   Dali::SignalConnectorType *result = 0 ;
22268
22269   arg1 = (Dali::TypeRegistration *)jarg1;
22270   if (!arg1) {
22271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22272     return 0;
22273   }
22274   if (!jarg2) {
22275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22276     return 0;
22277   }
22278   std::string arg2_str(jarg2);
22279   arg2 = &arg2_str;
22280   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22281   {
22282     try {
22283       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22284     } catch (std::out_of_range& e) {
22285       {
22286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22287       };
22288     } catch (std::exception& e) {
22289       {
22290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22291       };
22292     } catch (Dali::DaliException e) {
22293       {
22294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22295       };
22296     } catch (...) {
22297       {
22298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22299       };
22300     }
22301   }
22302
22303   jresult = (void *)result;
22304
22305   //argout typemap for const std::string&
22306
22307   return jresult;
22308 }
22309
22310
22311 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22312   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22313
22314   arg1 = (Dali::SignalConnectorType *)jarg1;
22315   {
22316     try {
22317       delete arg1;
22318     } catch (std::out_of_range& e) {
22319       {
22320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22321       };
22322     } catch (std::exception& e) {
22323       {
22324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22325       };
22326     } catch (Dali::DaliException e) {
22327       {
22328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22329       };
22330     } catch (...) {
22331       {
22332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22333       };
22334     }
22335   }
22336
22337 }
22338
22339
22340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22341   void * jresult ;
22342   Dali::TypeRegistration *arg1 = 0 ;
22343   std::string *arg2 = 0 ;
22344   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22345   Dali::TypeAction *result = 0 ;
22346
22347   arg1 = (Dali::TypeRegistration *)jarg1;
22348   if (!arg1) {
22349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22350     return 0;
22351   }
22352   if (!jarg2) {
22353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22354     return 0;
22355   }
22356   std::string arg2_str(jarg2);
22357   arg2 = &arg2_str;
22358   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22359   {
22360     try {
22361       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22362     } catch (std::out_of_range& e) {
22363       {
22364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22365       };
22366     } catch (std::exception& e) {
22367       {
22368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22369       };
22370     } catch (Dali::DaliException e) {
22371       {
22372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22373       };
22374     } catch (...) {
22375       {
22376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22377       };
22378     }
22379   }
22380
22381   jresult = (void *)result;
22382
22383   //argout typemap for const std::string&
22384
22385   return jresult;
22386 }
22387
22388
22389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22390   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22391
22392   arg1 = (Dali::TypeAction *)jarg1;
22393   {
22394     try {
22395       delete arg1;
22396     } catch (std::out_of_range& e) {
22397       {
22398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22399       };
22400     } catch (std::exception& e) {
22401       {
22402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22403       };
22404     } catch (Dali::DaliException e) {
22405       {
22406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22407       };
22408     } catch (...) {
22409       {
22410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22411       };
22412     }
22413   }
22414
22415 }
22416
22417
22418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22419   void * jresult ;
22420   Dali::TypeRegistration *arg1 = 0 ;
22421   std::string *arg2 = 0 ;
22422   Dali::Property::Index arg3 ;
22423   Dali::Property::Type arg4 ;
22424   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22425   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22426   Dali::PropertyRegistration *result = 0 ;
22427
22428   arg1 = (Dali::TypeRegistration *)jarg1;
22429   if (!arg1) {
22430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22431     return 0;
22432   }
22433   if (!jarg2) {
22434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22435     return 0;
22436   }
22437   std::string arg2_str(jarg2);
22438   arg2 = &arg2_str;
22439   arg3 = (Dali::Property::Index)jarg3;
22440   arg4 = (Dali::Property::Type)jarg4;
22441   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22442   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22443   {
22444     try {
22445       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22446     } catch (std::out_of_range& e) {
22447       {
22448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22449       };
22450     } catch (std::exception& e) {
22451       {
22452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22453       };
22454     } catch (Dali::DaliException e) {
22455       {
22456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22457       };
22458     } catch (...) {
22459       {
22460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22461       };
22462     }
22463   }
22464
22465   jresult = (void *)result;
22466
22467   //argout typemap for const std::string&
22468
22469   return jresult;
22470 }
22471
22472
22473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22474   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22475
22476   arg1 = (Dali::PropertyRegistration *)jarg1;
22477   {
22478     try {
22479       delete arg1;
22480     } catch (std::out_of_range& e) {
22481       {
22482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22483       };
22484     } catch (std::exception& e) {
22485       {
22486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22487       };
22488     } catch (Dali::DaliException e) {
22489       {
22490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22491       };
22492     } catch (...) {
22493       {
22494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22495       };
22496     }
22497   }
22498
22499 }
22500
22501
22502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22503   void * jresult ;
22504   Dali::TypeRegistration *arg1 = 0 ;
22505   std::string *arg2 = 0 ;
22506   Dali::Property::Index arg3 ;
22507   Dali::Property::Type arg4 ;
22508   Dali::AnimatablePropertyRegistration *result = 0 ;
22509
22510   arg1 = (Dali::TypeRegistration *)jarg1;
22511   if (!arg1) {
22512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22513     return 0;
22514   }
22515   if (!jarg2) {
22516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22517     return 0;
22518   }
22519   std::string arg2_str(jarg2);
22520   arg2 = &arg2_str;
22521   arg3 = (Dali::Property::Index)jarg3;
22522   arg4 = (Dali::Property::Type)jarg4;
22523   {
22524     try {
22525       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22526     } catch (std::out_of_range& e) {
22527       {
22528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22529       };
22530     } catch (std::exception& e) {
22531       {
22532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22533       };
22534     } catch (Dali::DaliException e) {
22535       {
22536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22537       };
22538     } catch (...) {
22539       {
22540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22541       };
22542     }
22543   }
22544
22545   jresult = (void *)result;
22546
22547   //argout typemap for const std::string&
22548
22549   return jresult;
22550 }
22551
22552
22553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22554   void * jresult ;
22555   Dali::TypeRegistration *arg1 = 0 ;
22556   std::string *arg2 = 0 ;
22557   Dali::Property::Index arg3 ;
22558   Dali::Property::Value *arg4 = 0 ;
22559   Dali::AnimatablePropertyRegistration *result = 0 ;
22560
22561   arg1 = (Dali::TypeRegistration *)jarg1;
22562   if (!arg1) {
22563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22564     return 0;
22565   }
22566   if (!jarg2) {
22567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22568     return 0;
22569   }
22570   std::string arg2_str(jarg2);
22571   arg2 = &arg2_str;
22572   arg3 = (Dali::Property::Index)jarg3;
22573   arg4 = (Dali::Property::Value *)jarg4;
22574   if (!arg4) {
22575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22576     return 0;
22577   }
22578   {
22579     try {
22580       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22581     } catch (std::out_of_range& e) {
22582       {
22583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22584       };
22585     } catch (std::exception& e) {
22586       {
22587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22588       };
22589     } catch (Dali::DaliException e) {
22590       {
22591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22592       };
22593     } catch (...) {
22594       {
22595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22596       };
22597     }
22598   }
22599
22600   jresult = (void *)result;
22601
22602   //argout typemap for const std::string&
22603
22604   return jresult;
22605 }
22606
22607
22608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22609   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22610
22611   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22612   {
22613     try {
22614       delete arg1;
22615     } catch (std::out_of_range& e) {
22616       {
22617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22618       };
22619     } catch (std::exception& e) {
22620       {
22621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22622       };
22623     } catch (Dali::DaliException e) {
22624       {
22625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22626       };
22627     } catch (...) {
22628       {
22629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22630       };
22631     }
22632   }
22633
22634 }
22635
22636
22637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22638   void * jresult ;
22639   Dali::TypeRegistration *arg1 = 0 ;
22640   std::string *arg2 = 0 ;
22641   Dali::Property::Index arg3 ;
22642   Dali::Property::Index arg4 ;
22643   unsigned int arg5 ;
22644   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22645
22646   arg1 = (Dali::TypeRegistration *)jarg1;
22647   if (!arg1) {
22648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22649     return 0;
22650   }
22651   if (!jarg2) {
22652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22653     return 0;
22654   }
22655   std::string arg2_str(jarg2);
22656   arg2 = &arg2_str;
22657   arg3 = (Dali::Property::Index)jarg3;
22658   arg4 = (Dali::Property::Index)jarg4;
22659   arg5 = (unsigned int)jarg5;
22660   {
22661     try {
22662       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22663     } catch (std::out_of_range& e) {
22664       {
22665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22666       };
22667     } catch (std::exception& e) {
22668       {
22669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22670       };
22671     } catch (Dali::DaliException e) {
22672       {
22673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22674       };
22675     } catch (...) {
22676       {
22677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22678       };
22679     }
22680   }
22681
22682   jresult = (void *)result;
22683
22684   //argout typemap for const std::string&
22685
22686   return jresult;
22687 }
22688
22689
22690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22691   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22692
22693   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22694   {
22695     try {
22696       delete arg1;
22697     } catch (std::out_of_range& e) {
22698       {
22699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22700       };
22701     } catch (std::exception& e) {
22702       {
22703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22704       };
22705     } catch (Dali::DaliException e) {
22706       {
22707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22708       };
22709     } catch (...) {
22710       {
22711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22712       };
22713     }
22714   }
22715
22716 }
22717
22718
22719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22720   void * jresult ;
22721   Dali::TypeRegistration *arg1 = 0 ;
22722   std::string *arg2 = 0 ;
22723   Dali::Property::Index arg3 ;
22724   Dali::Property::Type arg4 ;
22725   Dali::ChildPropertyRegistration *result = 0 ;
22726
22727   arg1 = (Dali::TypeRegistration *)jarg1;
22728   if (!arg1) {
22729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22730     return 0;
22731   }
22732   if (!jarg2) {
22733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22734     return 0;
22735   }
22736   std::string arg2_str(jarg2);
22737   arg2 = &arg2_str;
22738   arg3 = (Dali::Property::Index)jarg3;
22739   arg4 = (Dali::Property::Type)jarg4;
22740   {
22741     try {
22742       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22743     } catch (std::out_of_range& e) {
22744       {
22745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22746       };
22747     } catch (std::exception& e) {
22748       {
22749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22750       };
22751     } catch (Dali::DaliException e) {
22752       {
22753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22754       };
22755     } catch (...) {
22756       {
22757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22758       };
22759     }
22760   }
22761
22762   jresult = (void *)result;
22763
22764   //argout typemap for const std::string&
22765
22766   return jresult;
22767 }
22768
22769
22770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22771   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22772
22773   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22774   {
22775     try {
22776       delete arg1;
22777     } catch (std::out_of_range& e) {
22778       {
22779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22780       };
22781     } catch (std::exception& e) {
22782       {
22783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22784       };
22785     } catch (Dali::DaliException e) {
22786       {
22787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22788       };
22789     } catch (...) {
22790       {
22791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22792       };
22793     }
22794   }
22795
22796 }
22797
22798
22799 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22800   unsigned int jresult ;
22801   std::string *arg1 = 0 ;
22802   std::type_info *arg2 = 0 ;
22803   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22804   bool result;
22805
22806   if (!jarg1) {
22807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22808     return 0;
22809   }
22810   std::string arg1_str(jarg1);
22811   arg1 = &arg1_str;
22812   arg2 = (std::type_info *)jarg2;
22813   if (!arg2) {
22814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22815     return 0;
22816   }
22817   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22818   {
22819     try {
22820       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22821     } catch (std::out_of_range& e) {
22822       {
22823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22824       };
22825     } catch (std::exception& e) {
22826       {
22827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22828       };
22829     } catch (Dali::DaliException e) {
22830       {
22831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22832       };
22833     } catch (...) {
22834       {
22835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22836       };
22837     }
22838   }
22839
22840   jresult = result;
22841
22842   //argout typemap for const std::string&
22843
22844   return jresult;
22845 }
22846
22847
22848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22849   unsigned int jresult ;
22850   std::string *arg1 = 0 ;
22851   std::string *arg2 = 0 ;
22852   Dali::Property::Index arg3 ;
22853   Dali::Property::Type arg4 ;
22854   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22855   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22856   bool result;
22857
22858   if (!jarg1) {
22859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22860     return 0;
22861   }
22862   std::string arg1_str(jarg1);
22863   arg1 = &arg1_str;
22864   if (!jarg2) {
22865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22866     return 0;
22867   }
22868   std::string arg2_str(jarg2);
22869   arg2 = &arg2_str;
22870   arg3 = (Dali::Property::Index)jarg3;
22871   arg4 = (Dali::Property::Type)jarg4;
22872   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22873   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22874   {
22875     try {
22876       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22877     } catch (std::out_of_range& e) {
22878       {
22879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22880       };
22881     } catch (std::exception& e) {
22882       {
22883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22884       };
22885     } catch (Dali::DaliException e) {
22886       {
22887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22888       };
22889     } catch (...) {
22890       {
22891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22892       };
22893     }
22894   }
22895
22896   jresult = result;
22897
22898   //argout typemap for const std::string&
22899
22900
22901   //argout typemap for const std::string&
22902
22903   return jresult;
22904 }
22905
22906
22907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22908   float jresult ;
22909   float result;
22910
22911   result = (float)(float)Dali::ParentOrigin::TOP;
22912   jresult = result;
22913   return jresult;
22914 }
22915
22916
22917 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22918   float jresult ;
22919   float result;
22920
22921   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22922   jresult = result;
22923   return jresult;
22924 }
22925
22926
22927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22928   float jresult ;
22929   float result;
22930
22931   result = (float)(float)Dali::ParentOrigin::LEFT;
22932   jresult = result;
22933   return jresult;
22934 }
22935
22936
22937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22938   float jresult ;
22939   float result;
22940
22941   result = (float)(float)Dali::ParentOrigin::RIGHT;
22942   jresult = result;
22943   return jresult;
22944 }
22945
22946
22947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22948   float jresult ;
22949   float result;
22950
22951   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22952   jresult = result;
22953   return jresult;
22954 }
22955
22956
22957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22958   void * jresult ;
22959   Dali::Vector3 *result = 0 ;
22960
22961   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22962   jresult = (void *)result;
22963   return jresult;
22964 }
22965
22966
22967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22968   void * jresult ;
22969   Dali::Vector3 *result = 0 ;
22970
22971   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22972   jresult = (void *)result;
22973   return jresult;
22974 }
22975
22976
22977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22978   void * jresult ;
22979   Dali::Vector3 *result = 0 ;
22980
22981   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
22982   jresult = (void *)result;
22983   return jresult;
22984 }
22985
22986
22987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
22988   void * jresult ;
22989   Dali::Vector3 *result = 0 ;
22990
22991   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
22992   jresult = (void *)result;
22993   return jresult;
22994 }
22995
22996
22997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
22998   void * jresult ;
22999   Dali::Vector3 *result = 0 ;
23000
23001   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23002   jresult = (void *)result;
23003   return jresult;
23004 }
23005
23006
23007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23008   void * jresult ;
23009   Dali::Vector3 *result = 0 ;
23010
23011   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23012   jresult = (void *)result;
23013   return jresult;
23014 }
23015
23016
23017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23018   void * jresult ;
23019   Dali::Vector3 *result = 0 ;
23020
23021   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23022   jresult = (void *)result;
23023   return jresult;
23024 }
23025
23026
23027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23028   void * jresult ;
23029   Dali::Vector3 *result = 0 ;
23030
23031   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23032   jresult = (void *)result;
23033   return jresult;
23034 }
23035
23036
23037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23038   void * jresult ;
23039   Dali::Vector3 *result = 0 ;
23040
23041   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23042   jresult = (void *)result;
23043   return jresult;
23044 }
23045
23046
23047 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23048   float jresult ;
23049   float result;
23050
23051   result = (float)(float)Dali::AnchorPoint::TOP;
23052   jresult = result;
23053   return jresult;
23054 }
23055
23056
23057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23058   float jresult ;
23059   float result;
23060
23061   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23062   jresult = result;
23063   return jresult;
23064 }
23065
23066
23067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23068   float jresult ;
23069   float result;
23070
23071   result = (float)(float)Dali::AnchorPoint::LEFT;
23072   jresult = result;
23073   return jresult;
23074 }
23075
23076
23077 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23078   float jresult ;
23079   float result;
23080
23081   result = (float)(float)Dali::AnchorPoint::RIGHT;
23082   jresult = result;
23083   return jresult;
23084 }
23085
23086
23087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23088   float jresult ;
23089   float result;
23090
23091   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23092   jresult = result;
23093   return jresult;
23094 }
23095
23096
23097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23098   void * jresult ;
23099   Dali::Vector3 *result = 0 ;
23100
23101   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23102   jresult = (void *)result;
23103   return jresult;
23104 }
23105
23106
23107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23108   void * jresult ;
23109   Dali::Vector3 *result = 0 ;
23110
23111   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23112   jresult = (void *)result;
23113   return jresult;
23114 }
23115
23116
23117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23118   void * jresult ;
23119   Dali::Vector3 *result = 0 ;
23120
23121   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23122   jresult = (void *)result;
23123   return jresult;
23124 }
23125
23126
23127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23128   void * jresult ;
23129   Dali::Vector3 *result = 0 ;
23130
23131   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23132   jresult = (void *)result;
23133   return jresult;
23134 }
23135
23136
23137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23138   void * jresult ;
23139   Dali::Vector3 *result = 0 ;
23140
23141   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23142   jresult = (void *)result;
23143   return jresult;
23144 }
23145
23146
23147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23148   void * jresult ;
23149   Dali::Vector3 *result = 0 ;
23150
23151   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23152   jresult = (void *)result;
23153   return jresult;
23154 }
23155
23156
23157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23158   void * jresult ;
23159   Dali::Vector3 *result = 0 ;
23160
23161   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23162   jresult = (void *)result;
23163   return jresult;
23164 }
23165
23166
23167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23168   void * jresult ;
23169   Dali::Vector3 *result = 0 ;
23170
23171   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23172   jresult = (void *)result;
23173   return jresult;
23174 }
23175
23176
23177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23178   void * jresult ;
23179   Dali::Vector3 *result = 0 ;
23180
23181   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23182   jresult = (void *)result;
23183   return jresult;
23184 }
23185
23186
23187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23188   void * jresult ;
23189   Dali::Vector4 *result = 0 ;
23190
23191   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23192   jresult = (void *)result;
23193   return jresult;
23194 }
23195
23196
23197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23198   void * jresult ;
23199   Dali::Vector4 *result = 0 ;
23200
23201   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23202   jresult = (void *)result;
23203   return jresult;
23204 }
23205
23206
23207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23208   void * jresult ;
23209   Dali::Vector4 *result = 0 ;
23210
23211   result = (Dali::Vector4 *)&Dali::Color::RED;
23212   jresult = (void *)result;
23213   return jresult;
23214 }
23215
23216
23217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23218   void * jresult ;
23219   Dali::Vector4 *result = 0 ;
23220
23221   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23222   jresult = (void *)result;
23223   return jresult;
23224 }
23225
23226
23227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23228   void * jresult ;
23229   Dali::Vector4 *result = 0 ;
23230
23231   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23232   jresult = (void *)result;
23233   return jresult;
23234 }
23235
23236
23237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23238   void * jresult ;
23239   Dali::Vector4 *result = 0 ;
23240
23241   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23242   jresult = (void *)result;
23243   return jresult;
23244 }
23245
23246
23247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23248   void * jresult ;
23249   Dali::Vector4 *result = 0 ;
23250
23251   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23252   jresult = (void *)result;
23253   return jresult;
23254 }
23255
23256
23257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23258   void * jresult ;
23259   Dali::Vector4 *result = 0 ;
23260
23261   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23262   jresult = (void *)result;
23263   return jresult;
23264 }
23265
23266
23267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23268   void * jresult ;
23269   Dali::Vector4 *result = 0 ;
23270
23271   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23272   jresult = (void *)result;
23273   return jresult;
23274 }
23275
23276
23277 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23278   float jresult ;
23279   float result;
23280
23281   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23282   jresult = result;
23283   return jresult;
23284 }
23285
23286
23287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23288   float jresult ;
23289   float result;
23290
23291   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23292   jresult = result;
23293   return jresult;
23294 }
23295
23296
23297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23298   float jresult ;
23299   float result;
23300
23301   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23302   jresult = result;
23303   return jresult;
23304 }
23305
23306
23307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23308   float jresult ;
23309   float result;
23310
23311   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23312   jresult = result;
23313   return jresult;
23314 }
23315
23316
23317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23318   float jresult ;
23319   float result;
23320
23321   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23322   jresult = result;
23323   return jresult;
23324 }
23325
23326
23327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23328   float jresult ;
23329   float result;
23330
23331   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23332   jresult = result;
23333   return jresult;
23334 }
23335
23336
23337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23338   float jresult ;
23339   float result;
23340
23341   result = (float)(float)Dali::Math::PI;
23342   jresult = result;
23343   return jresult;
23344 }
23345
23346
23347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23348   float jresult ;
23349   float result;
23350
23351   result = (float)(float)Dali::Math::PI_2;
23352   jresult = result;
23353   return jresult;
23354 }
23355
23356
23357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23358   float jresult ;
23359   float result;
23360
23361   result = (float)(float)Dali::Math::PI_4;
23362   jresult = result;
23363   return jresult;
23364 }
23365
23366
23367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23368   float jresult ;
23369   float result;
23370
23371   result = (float)(float)Dali::Math::PI_OVER_180;
23372   jresult = result;
23373   return jresult;
23374 }
23375
23376
23377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23378   float jresult ;
23379   float result;
23380
23381   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23382   jresult = result;
23383   return jresult;
23384 }
23385
23386
23387 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23388   int jresult ;
23389   Dali::ResizePolicy::Type result;
23390
23391   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23392   jresult = (int)result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23398   unsigned long jresult ;
23399   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23400   Dali::VectorBase::SizeType result;
23401
23402   arg1 = (Dali::VectorBase *)jarg1;
23403   {
23404     try {
23405       result = ((Dali::VectorBase const *)arg1)->Count();
23406     } catch (std::out_of_range& e) {
23407       {
23408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23409       };
23410     } catch (std::exception& e) {
23411       {
23412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23413       };
23414     } catch (Dali::DaliException e) {
23415       {
23416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23417       };
23418     } catch (...) {
23419       {
23420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23421       };
23422     }
23423   }
23424
23425   jresult = (unsigned long)result;
23426   return jresult;
23427 }
23428
23429
23430 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23431   unsigned long jresult ;
23432   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23433   Dali::VectorBase::SizeType result;
23434
23435   arg1 = (Dali::VectorBase *)jarg1;
23436   {
23437     try {
23438       result = ((Dali::VectorBase const *)arg1)->Size();
23439     } catch (std::out_of_range& e) {
23440       {
23441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23442       };
23443     } catch (std::exception& e) {
23444       {
23445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23446       };
23447     } catch (Dali::DaliException e) {
23448       {
23449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23450       };
23451     } catch (...) {
23452       {
23453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23454       };
23455     }
23456   }
23457
23458   jresult = (unsigned long)result;
23459   return jresult;
23460 }
23461
23462
23463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23464   unsigned int jresult ;
23465   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23466   bool result;
23467
23468   arg1 = (Dali::VectorBase *)jarg1;
23469   {
23470     try {
23471       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23472     } catch (std::out_of_range& e) {
23473       {
23474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23475       };
23476     } catch (std::exception& e) {
23477       {
23478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23479       };
23480     } catch (Dali::DaliException e) {
23481       {
23482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23483       };
23484     } catch (...) {
23485       {
23486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23487       };
23488     }
23489   }
23490
23491   jresult = result;
23492   return jresult;
23493 }
23494
23495
23496 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23497   unsigned long jresult ;
23498   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23499   Dali::VectorBase::SizeType result;
23500
23501   arg1 = (Dali::VectorBase *)jarg1;
23502   {
23503     try {
23504       result = ((Dali::VectorBase const *)arg1)->Capacity();
23505     } catch (std::out_of_range& e) {
23506       {
23507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23508       };
23509     } catch (std::exception& e) {
23510       {
23511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23512       };
23513     } catch (Dali::DaliException e) {
23514       {
23515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23516       };
23517     } catch (...) {
23518       {
23519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23520       };
23521     }
23522   }
23523
23524   jresult = (unsigned long)result;
23525   return jresult;
23526 }
23527
23528
23529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23530   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23531
23532   arg1 = (Dali::VectorBase *)jarg1;
23533   {
23534     try {
23535       (arg1)->Release();
23536     } catch (std::out_of_range& e) {
23537       {
23538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23539       };
23540     } catch (std::exception& e) {
23541       {
23542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23543       };
23544     } catch (Dali::DaliException e) {
23545       {
23546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23547       };
23548     } catch (...) {
23549       {
23550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23551       };
23552     }
23553   }
23554
23555 }
23556
23557
23558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23559   void * jresult ;
23560   Dali::Image *result = 0 ;
23561
23562   {
23563     try {
23564       result = (Dali::Image *)new Dali::Image();
23565     } catch (std::out_of_range& e) {
23566       {
23567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23568       };
23569     } catch (std::exception& e) {
23570       {
23571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23572       };
23573     } catch (Dali::DaliException e) {
23574       {
23575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23576       };
23577     } catch (...) {
23578       {
23579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23580       };
23581     }
23582   }
23583
23584   jresult = (void *)result;
23585   return jresult;
23586 }
23587
23588
23589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23590   Dali::Image *arg1 = (Dali::Image *) 0 ;
23591
23592   arg1 = (Dali::Image *)jarg1;
23593   {
23594     try {
23595       delete arg1;
23596     } catch (std::out_of_range& e) {
23597       {
23598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23599       };
23600     } catch (std::exception& e) {
23601       {
23602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23603       };
23604     } catch (Dali::DaliException e) {
23605       {
23606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23607       };
23608     } catch (...) {
23609       {
23610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23611       };
23612     }
23613   }
23614
23615 }
23616
23617
23618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23619   void * jresult ;
23620   Dali::Image *arg1 = 0 ;
23621   Dali::Image *result = 0 ;
23622
23623   arg1 = (Dali::Image *)jarg1;
23624   if (!arg1) {
23625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23626     return 0;
23627   }
23628   {
23629     try {
23630       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23631     } catch (std::out_of_range& e) {
23632       {
23633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23634       };
23635     } catch (std::exception& e) {
23636       {
23637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23638       };
23639     } catch (Dali::DaliException e) {
23640       {
23641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23642       };
23643     } catch (...) {
23644       {
23645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23646       };
23647     }
23648   }
23649
23650   jresult = (void *)result;
23651   return jresult;
23652 }
23653
23654
23655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23656   void * jresult ;
23657   Dali::Image *arg1 = (Dali::Image *) 0 ;
23658   Dali::Image *arg2 = 0 ;
23659   Dali::Image *result = 0 ;
23660
23661   arg1 = (Dali::Image *)jarg1;
23662   arg2 = (Dali::Image *)jarg2;
23663   if (!arg2) {
23664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23665     return 0;
23666   }
23667   {
23668     try {
23669       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23670     } catch (std::out_of_range& e) {
23671       {
23672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23673       };
23674     } catch (std::exception& e) {
23675       {
23676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23677       };
23678     } catch (Dali::DaliException e) {
23679       {
23680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23681       };
23682     } catch (...) {
23683       {
23684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23685       };
23686     }
23687   }
23688
23689   jresult = (void *)result;
23690   return jresult;
23691 }
23692
23693
23694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23695   void * jresult ;
23696   Dali::BaseHandle arg1 ;
23697   Dali::BaseHandle *argp1 ;
23698   Dali::Image result;
23699
23700   argp1 = (Dali::BaseHandle *)jarg1;
23701   if (!argp1) {
23702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23703     return 0;
23704   }
23705   arg1 = *argp1;
23706   {
23707     try {
23708       result = Dali::Image::DownCast(arg1);
23709     } catch (std::out_of_range& e) {
23710       {
23711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23712       };
23713     } catch (std::exception& e) {
23714       {
23715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23716       };
23717     } catch (Dali::DaliException e) {
23718       {
23719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23720       };
23721     } catch (...) {
23722       {
23723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23724       };
23725     }
23726   }
23727
23728   jresult = new Dali::Image((const Dali::Image &)result);
23729   return jresult;
23730 }
23731
23732
23733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23734   unsigned int jresult ;
23735   Dali::Image *arg1 = (Dali::Image *) 0 ;
23736   unsigned int result;
23737
23738   arg1 = (Dali::Image *)jarg1;
23739   {
23740     try {
23741       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23742     } catch (std::out_of_range& e) {
23743       {
23744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23745       };
23746     } catch (std::exception& e) {
23747       {
23748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23749       };
23750     } catch (Dali::DaliException e) {
23751       {
23752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23753       };
23754     } catch (...) {
23755       {
23756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23757       };
23758     }
23759   }
23760
23761   jresult = result;
23762   return jresult;
23763 }
23764
23765
23766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23767   unsigned int jresult ;
23768   Dali::Image *arg1 = (Dali::Image *) 0 ;
23769   unsigned int result;
23770
23771   arg1 = (Dali::Image *)jarg1;
23772   {
23773     try {
23774       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23775     } catch (std::out_of_range& e) {
23776       {
23777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23778       };
23779     } catch (std::exception& e) {
23780       {
23781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23782       };
23783     } catch (Dali::DaliException e) {
23784       {
23785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23786       };
23787     } catch (...) {
23788       {
23789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23790       };
23791     }
23792   }
23793
23794   jresult = result;
23795   return jresult;
23796 }
23797
23798
23799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23800   void * jresult ;
23801   Dali::Image *arg1 = (Dali::Image *) 0 ;
23802   Dali::Image::ImageSignalType *result = 0 ;
23803
23804   arg1 = (Dali::Image *)jarg1;
23805   {
23806     try {
23807       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23808     } catch (std::out_of_range& e) {
23809       {
23810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23811       };
23812     } catch (std::exception& e) {
23813       {
23814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23815       };
23816     } catch (Dali::DaliException e) {
23817       {
23818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23819       };
23820     } catch (...) {
23821       {
23822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23823       };
23824     }
23825   }
23826
23827   jresult = (void *)result;
23828   return jresult;
23829 }
23830
23831
23832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23833   int jresult ;
23834   Dali::Pixel::Format result;
23835
23836   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23837   jresult = (int)result;
23838   return jresult;
23839 }
23840
23841
23842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23843   int jresult ;
23844   Dali::Pixel::Format result;
23845
23846   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23847   jresult = (int)result;
23848   return jresult;
23849 }
23850
23851
23852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23853   unsigned int jresult ;
23854   Dali::Pixel::Format arg1 ;
23855   bool result;
23856
23857   arg1 = (Dali::Pixel::Format)jarg1;
23858   {
23859     try {
23860       result = (bool)Dali::Pixel::HasAlpha(arg1);
23861     } catch (std::out_of_range& e) {
23862       {
23863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23864       };
23865     } catch (std::exception& e) {
23866       {
23867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23868       };
23869     } catch (Dali::DaliException e) {
23870       {
23871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23872       };
23873     } catch (...) {
23874       {
23875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23876       };
23877     }
23878   }
23879
23880   jresult = result;
23881   return jresult;
23882 }
23883
23884
23885 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23886   unsigned int jresult ;
23887   Dali::Pixel::Format arg1 ;
23888   unsigned int result;
23889
23890   arg1 = (Dali::Pixel::Format)jarg1;
23891   {
23892     try {
23893       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23894     } catch (std::out_of_range& e) {
23895       {
23896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23897       };
23898     } catch (std::exception& e) {
23899       {
23900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23901       };
23902     } catch (Dali::DaliException e) {
23903       {
23904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23905       };
23906     } catch (...) {
23907       {
23908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23909       };
23910     }
23911   }
23912
23913   jresult = result;
23914   return jresult;
23915 }
23916
23917
23918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23919   Dali::Pixel::Format arg1 ;
23920   int *arg2 = 0 ;
23921   int *arg3 = 0 ;
23922
23923   arg1 = (Dali::Pixel::Format)jarg1;
23924   arg2 = (int *)jarg2;
23925   if (!arg2) {
23926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23927     return ;
23928   }
23929   arg3 = (int *)jarg3;
23930   if (!arg3) {
23931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23932     return ;
23933   }
23934   {
23935     try {
23936       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23937     } catch (std::out_of_range& e) {
23938       {
23939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23940       };
23941     } catch (std::exception& e) {
23942       {
23943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23944       };
23945     } catch (Dali::DaliException e) {
23946       {
23947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23948       };
23949     } catch (...) {
23950       {
23951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23952       };
23953     }
23954   }
23955
23956 }
23957
23958
23959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23960   void * jresult ;
23961   unsigned char *arg1 = (unsigned char *) 0 ;
23962   unsigned int arg2 ;
23963   unsigned int arg3 ;
23964   unsigned int arg4 ;
23965   Dali::Pixel::Format arg5 ;
23966   Dali::PixelData::ReleaseFunction arg6 ;
23967   Dali::PixelData result;
23968
23969   arg1 = jarg1;
23970   arg2 = (unsigned int)jarg2;
23971   arg3 = (unsigned int)jarg3;
23972   arg4 = (unsigned int)jarg4;
23973   arg5 = (Dali::Pixel::Format)jarg5;
23974   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23975   {
23976     try {
23977       auto pixelBuffer = new unsigned char[jarg2];
23978       memcpy( pixelBuffer, arg1, arg2);
23979       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23980     } catch (std::out_of_range& e) {
23981       {
23982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23983       };
23984     } catch (std::exception& e) {
23985       {
23986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23987       };
23988     } catch (Dali::DaliException e) {
23989       {
23990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23991       };
23992     } catch (...) {
23993       {
23994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23995       };
23996     }
23997   }
23998
23999   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24000
24001
24002   return jresult;
24003 }
24004
24005
24006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24007   void * jresult ;
24008   Dali::PixelData *result = 0 ;
24009
24010   {
24011     try {
24012       result = (Dali::PixelData *)new Dali::PixelData();
24013     } catch (std::out_of_range& e) {
24014       {
24015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24016       };
24017     } catch (std::exception& e) {
24018       {
24019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24020       };
24021     } catch (Dali::DaliException e) {
24022       {
24023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24024       };
24025     } catch (...) {
24026       {
24027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24028       };
24029     }
24030   }
24031
24032   jresult = (void *)result;
24033   return jresult;
24034 }
24035
24036
24037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24038   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24039
24040   arg1 = (Dali::PixelData *)jarg1;
24041   {
24042     try {
24043       delete arg1;
24044     } catch (std::out_of_range& e) {
24045       {
24046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24047       };
24048     } catch (std::exception& e) {
24049       {
24050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24051       };
24052     } catch (Dali::DaliException e) {
24053       {
24054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24055       };
24056     } catch (...) {
24057       {
24058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24059       };
24060     }
24061   }
24062
24063 }
24064
24065
24066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24067   void * jresult ;
24068   Dali::PixelData *arg1 = 0 ;
24069   Dali::PixelData *result = 0 ;
24070
24071   arg1 = (Dali::PixelData *)jarg1;
24072   if (!arg1) {
24073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24074     return 0;
24075   }
24076   {
24077     try {
24078       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24079     } catch (std::out_of_range& e) {
24080       {
24081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24082       };
24083     } catch (std::exception& e) {
24084       {
24085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24086       };
24087     } catch (Dali::DaliException e) {
24088       {
24089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24090       };
24091     } catch (...) {
24092       {
24093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24094       };
24095     }
24096   }
24097
24098   jresult = (void *)result;
24099   return jresult;
24100 }
24101
24102
24103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24104   void * jresult ;
24105   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24106   Dali::PixelData *arg2 = 0 ;
24107   Dali::PixelData *result = 0 ;
24108
24109   arg1 = (Dali::PixelData *)jarg1;
24110   arg2 = (Dali::PixelData *)jarg2;
24111   if (!arg2) {
24112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24113     return 0;
24114   }
24115   {
24116     try {
24117       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24118     } catch (std::out_of_range& e) {
24119       {
24120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24121       };
24122     } catch (std::exception& e) {
24123       {
24124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24125       };
24126     } catch (Dali::DaliException e) {
24127       {
24128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24129       };
24130     } catch (...) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24133       };
24134     }
24135   }
24136
24137   jresult = (void *)result;
24138   return jresult;
24139 }
24140
24141
24142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24143   unsigned int jresult ;
24144   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24145   unsigned int result;
24146
24147   arg1 = (Dali::PixelData *)jarg1;
24148   {
24149     try {
24150       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24151     } catch (std::out_of_range& e) {
24152       {
24153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24154       };
24155     } catch (std::exception& e) {
24156       {
24157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24158       };
24159     } catch (Dali::DaliException e) {
24160       {
24161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24162       };
24163     } catch (...) {
24164       {
24165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24166       };
24167     }
24168   }
24169
24170   jresult = result;
24171   return jresult;
24172 }
24173
24174
24175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24176   unsigned int jresult ;
24177   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24178   unsigned int result;
24179
24180   arg1 = (Dali::PixelData *)jarg1;
24181   {
24182     try {
24183       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24184     } catch (std::out_of_range& e) {
24185       {
24186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24187       };
24188     } catch (std::exception& e) {
24189       {
24190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24191       };
24192     } catch (Dali::DaliException e) {
24193       {
24194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24195       };
24196     } catch (...) {
24197       {
24198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24199       };
24200     }
24201   }
24202
24203   jresult = result;
24204   return jresult;
24205 }
24206
24207
24208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24209   int jresult ;
24210   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24211   Dali::Pixel::Format result;
24212
24213   arg1 = (Dali::PixelData *)jarg1;
24214   {
24215     try {
24216       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24217     } catch (std::out_of_range& e) {
24218       {
24219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24220       };
24221     } catch (std::exception& e) {
24222       {
24223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24224       };
24225     } catch (Dali::DaliException e) {
24226       {
24227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24228       };
24229     } catch (...) {
24230       {
24231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24232       };
24233     }
24234   }
24235
24236   jresult = (int)result;
24237   return jresult;
24238 }
24239
24240
24241 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24242   unsigned int jresult ;
24243   unsigned int result;
24244
24245   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24246   jresult = result;
24247   return jresult;
24248 }
24249
24250
24251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24252   unsigned int jresult ;
24253   unsigned int result;
24254
24255   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24256   jresult = result;
24257   return jresult;
24258 }
24259
24260
24261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24262   unsigned int jresult ;
24263   unsigned int result;
24264
24265   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24266   jresult = result;
24267   return jresult;
24268 }
24269
24270
24271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24272   unsigned int jresult ;
24273   unsigned int result;
24274
24275   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24276   jresult = result;
24277   return jresult;
24278 }
24279
24280
24281 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24282   unsigned int jresult ;
24283   unsigned int result;
24284
24285   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24286   jresult = result;
24287   return jresult;
24288 }
24289
24290
24291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24292   unsigned int jresult ;
24293   unsigned int result;
24294
24295   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24296   jresult = result;
24297   return jresult;
24298 }
24299
24300
24301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24302   void * jresult ;
24303   Dali::TextureType::Type arg1 ;
24304   Dali::Pixel::Format arg2 ;
24305   unsigned int arg3 ;
24306   unsigned int arg4 ;
24307   Dali::Texture result;
24308
24309   arg1 = (Dali::TextureType::Type)jarg1;
24310   arg2 = (Dali::Pixel::Format)jarg2;
24311   arg3 = (unsigned int)jarg3;
24312   arg4 = (unsigned int)jarg4;
24313   {
24314     try {
24315       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24316     } catch (std::out_of_range& e) {
24317       {
24318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24319       };
24320     } catch (std::exception& e) {
24321       {
24322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24323       };
24324     } catch (Dali::DaliException e) {
24325       {
24326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24327       };
24328     } catch (...) {
24329       {
24330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24331       };
24332     }
24333   }
24334
24335   jresult = new Dali::Texture((const Dali::Texture &)result);
24336   return jresult;
24337 }
24338
24339
24340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24341   void * jresult ;
24342   NativeImageInterface *arg1 = 0 ;
24343   Dali::Texture result;
24344
24345   arg1 = (NativeImageInterface *)jarg1;
24346   if (!arg1) {
24347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24348     return 0;
24349   }
24350   {
24351     try {
24352       result = Dali::Texture::New(*arg1);
24353     } catch (std::out_of_range& e) {
24354       {
24355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24356       };
24357     } catch (std::exception& e) {
24358       {
24359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24360       };
24361     } catch (Dali::DaliException e) {
24362       {
24363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24364       };
24365     } catch (...) {
24366       {
24367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24368       };
24369     }
24370   }
24371
24372   jresult = new Dali::Texture((const Dali::Texture &)result);
24373   return jresult;
24374 }
24375
24376
24377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24378   void * jresult ;
24379   Dali::Texture *result = 0 ;
24380
24381   {
24382     try {
24383       result = (Dali::Texture *)new Dali::Texture();
24384     } catch (std::out_of_range& e) {
24385       {
24386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24387       };
24388     } catch (std::exception& e) {
24389       {
24390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24391       };
24392     } catch (Dali::DaliException e) {
24393       {
24394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24395       };
24396     } catch (...) {
24397       {
24398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24399       };
24400     }
24401   }
24402
24403   jresult = (void *)result;
24404   return jresult;
24405 }
24406
24407
24408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24409   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24410
24411   arg1 = (Dali::Texture *)jarg1;
24412   {
24413     try {
24414       delete arg1;
24415     } catch (std::out_of_range& e) {
24416       {
24417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24418       };
24419     } catch (std::exception& e) {
24420       {
24421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24422       };
24423     } catch (Dali::DaliException e) {
24424       {
24425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24426       };
24427     } catch (...) {
24428       {
24429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24430       };
24431     }
24432   }
24433
24434 }
24435
24436
24437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24438   void * jresult ;
24439   Dali::Texture *arg1 = 0 ;
24440   Dali::Texture *result = 0 ;
24441
24442   arg1 = (Dali::Texture *)jarg1;
24443   if (!arg1) {
24444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24445     return 0;
24446   }
24447   {
24448     try {
24449       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24450     } catch (std::out_of_range& e) {
24451       {
24452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24453       };
24454     } catch (std::exception& e) {
24455       {
24456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24457       };
24458     } catch (Dali::DaliException e) {
24459       {
24460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24461       };
24462     } catch (...) {
24463       {
24464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24465       };
24466     }
24467   }
24468
24469   jresult = (void *)result;
24470   return jresult;
24471 }
24472
24473
24474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24475   void * jresult ;
24476   Dali::BaseHandle arg1 ;
24477   Dali::BaseHandle *argp1 ;
24478   Dali::Texture result;
24479
24480   argp1 = (Dali::BaseHandle *)jarg1;
24481   if (!argp1) {
24482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24483     return 0;
24484   }
24485   arg1 = *argp1;
24486   {
24487     try {
24488       result = Dali::Texture::DownCast(arg1);
24489     } catch (std::out_of_range& e) {
24490       {
24491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24492       };
24493     } catch (std::exception& e) {
24494       {
24495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24496       };
24497     } catch (Dali::DaliException e) {
24498       {
24499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24500       };
24501     } catch (...) {
24502       {
24503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24504       };
24505     }
24506   }
24507
24508   jresult = new Dali::Texture((const Dali::Texture &)result);
24509   return jresult;
24510 }
24511
24512
24513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24514   void * jresult ;
24515   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24516   Dali::Texture *arg2 = 0 ;
24517   Dali::Texture *result = 0 ;
24518
24519   arg1 = (Dali::Texture *)jarg1;
24520   arg2 = (Dali::Texture *)jarg2;
24521   if (!arg2) {
24522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24523     return 0;
24524   }
24525   {
24526     try {
24527       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24528     } catch (std::out_of_range& e) {
24529       {
24530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24531       };
24532     } catch (std::exception& e) {
24533       {
24534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24535       };
24536     } catch (Dali::DaliException e) {
24537       {
24538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24539       };
24540     } catch (...) {
24541       {
24542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24543       };
24544     }
24545   }
24546
24547   jresult = (void *)result;
24548   return jresult;
24549 }
24550
24551
24552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24553   unsigned int jresult ;
24554   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24555   Dali::PixelData arg2 ;
24556   Dali::PixelData *argp2 ;
24557   bool result;
24558
24559   arg1 = (Dali::Texture *)jarg1;
24560   argp2 = (Dali::PixelData *)jarg2;
24561   if (!argp2) {
24562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24563     return 0;
24564   }
24565   arg2 = *argp2;
24566   {
24567     try {
24568       result = (bool)(arg1)->Upload(arg2);
24569     } catch (std::out_of_range& e) {
24570       {
24571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24572       };
24573     } catch (std::exception& e) {
24574       {
24575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24576       };
24577     } catch (Dali::DaliException e) {
24578       {
24579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24580       };
24581     } catch (...) {
24582       {
24583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24584       };
24585     }
24586   }
24587
24588   jresult = result;
24589   return jresult;
24590 }
24591
24592
24593 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) {
24594   unsigned int jresult ;
24595   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24596   Dali::PixelData arg2 ;
24597   unsigned int arg3 ;
24598   unsigned int arg4 ;
24599   unsigned int arg5 ;
24600   unsigned int arg6 ;
24601   unsigned int arg7 ;
24602   unsigned int arg8 ;
24603   Dali::PixelData *argp2 ;
24604   bool result;
24605
24606   arg1 = (Dali::Texture *)jarg1;
24607   argp2 = (Dali::PixelData *)jarg2;
24608   if (!argp2) {
24609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24610     return 0;
24611   }
24612   arg2 = *argp2;
24613   arg3 = (unsigned int)jarg3;
24614   arg4 = (unsigned int)jarg4;
24615   arg5 = (unsigned int)jarg5;
24616   arg6 = (unsigned int)jarg6;
24617   arg7 = (unsigned int)jarg7;
24618   arg8 = (unsigned int)jarg8;
24619   {
24620     try {
24621       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24622     } catch (std::out_of_range& e) {
24623       {
24624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24625       };
24626     } catch (std::exception& e) {
24627       {
24628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24629       };
24630     } catch (Dali::DaliException e) {
24631       {
24632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24633       };
24634     } catch (...) {
24635       {
24636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24637       };
24638     }
24639   }
24640
24641   jresult = result;
24642   return jresult;
24643 }
24644
24645
24646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24647   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24648
24649   arg1 = (Dali::Texture *)jarg1;
24650   {
24651     try {
24652       (arg1)->GenerateMipmaps();
24653     } catch (std::out_of_range& e) {
24654       {
24655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24656       };
24657     } catch (std::exception& e) {
24658       {
24659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24660       };
24661     } catch (Dali::DaliException e) {
24662       {
24663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24664       };
24665     } catch (...) {
24666       {
24667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24668       };
24669     }
24670   }
24671
24672 }
24673
24674
24675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24676   unsigned int jresult ;
24677   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24678   unsigned int result;
24679
24680   arg1 = (Dali::Texture *)jarg1;
24681   {
24682     try {
24683       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24684     } catch (std::out_of_range& e) {
24685       {
24686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24687       };
24688     } catch (std::exception& e) {
24689       {
24690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24691       };
24692     } catch (Dali::DaliException e) {
24693       {
24694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24695       };
24696     } catch (...) {
24697       {
24698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24699       };
24700     }
24701   }
24702
24703   jresult = result;
24704   return jresult;
24705 }
24706
24707
24708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24709   unsigned int jresult ;
24710   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24711   unsigned int result;
24712
24713   arg1 = (Dali::Texture *)jarg1;
24714   {
24715     try {
24716       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24717     } catch (std::out_of_range& e) {
24718       {
24719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24720       };
24721     } catch (std::exception& e) {
24722       {
24723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24724       };
24725     } catch (Dali::DaliException e) {
24726       {
24727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24728       };
24729     } catch (...) {
24730       {
24731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24732       };
24733     }
24734   }
24735
24736   jresult = result;
24737   return jresult;
24738 }
24739
24740
24741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24742   void * jresult ;
24743   Dali::Sampler result;
24744
24745   {
24746     try {
24747       result = Dali::Sampler::New();
24748     } catch (std::out_of_range& e) {
24749       {
24750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24751       };
24752     } catch (std::exception& e) {
24753       {
24754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24755       };
24756     } catch (Dali::DaliException e) {
24757       {
24758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24759       };
24760     } catch (...) {
24761       {
24762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24763       };
24764     }
24765   }
24766
24767   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24768   return jresult;
24769 }
24770
24771
24772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24773   void * jresult ;
24774   Dali::Sampler *result = 0 ;
24775
24776   {
24777     try {
24778       result = (Dali::Sampler *)new Dali::Sampler();
24779     } catch (std::out_of_range& e) {
24780       {
24781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24782       };
24783     } catch (std::exception& e) {
24784       {
24785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24786       };
24787     } catch (Dali::DaliException e) {
24788       {
24789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24790       };
24791     } catch (...) {
24792       {
24793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24794       };
24795     }
24796   }
24797
24798   jresult = (void *)result;
24799   return jresult;
24800 }
24801
24802
24803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24804   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24805
24806   arg1 = (Dali::Sampler *)jarg1;
24807   {
24808     try {
24809       delete arg1;
24810     } catch (std::out_of_range& e) {
24811       {
24812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24813       };
24814     } catch (std::exception& e) {
24815       {
24816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24817       };
24818     } catch (Dali::DaliException e) {
24819       {
24820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24821       };
24822     } catch (...) {
24823       {
24824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24825       };
24826     }
24827   }
24828
24829 }
24830
24831
24832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24833   void * jresult ;
24834   Dali::Sampler *arg1 = 0 ;
24835   Dali::Sampler *result = 0 ;
24836
24837   arg1 = (Dali::Sampler *)jarg1;
24838   if (!arg1) {
24839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24840     return 0;
24841   }
24842   {
24843     try {
24844       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24845     } catch (std::out_of_range& e) {
24846       {
24847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24848       };
24849     } catch (std::exception& e) {
24850       {
24851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24852       };
24853     } catch (Dali::DaliException e) {
24854       {
24855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24856       };
24857     } catch (...) {
24858       {
24859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24860       };
24861     }
24862   }
24863
24864   jresult = (void *)result;
24865   return jresult;
24866 }
24867
24868
24869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24870   void * jresult ;
24871   Dali::BaseHandle arg1 ;
24872   Dali::BaseHandle *argp1 ;
24873   Dali::Sampler result;
24874
24875   argp1 = (Dali::BaseHandle *)jarg1;
24876   if (!argp1) {
24877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24878     return 0;
24879   }
24880   arg1 = *argp1;
24881   {
24882     try {
24883       result = Dali::Sampler::DownCast(arg1);
24884     } catch (std::out_of_range& e) {
24885       {
24886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24887       };
24888     } catch (std::exception& e) {
24889       {
24890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24891       };
24892     } catch (Dali::DaliException e) {
24893       {
24894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24895       };
24896     } catch (...) {
24897       {
24898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24899       };
24900     }
24901   }
24902
24903   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24904   return jresult;
24905 }
24906
24907
24908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24909   void * jresult ;
24910   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24911   Dali::Sampler *arg2 = 0 ;
24912   Dali::Sampler *result = 0 ;
24913
24914   arg1 = (Dali::Sampler *)jarg1;
24915   arg2 = (Dali::Sampler *)jarg2;
24916   if (!arg2) {
24917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24918     return 0;
24919   }
24920   {
24921     try {
24922       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24923     } catch (std::out_of_range& e) {
24924       {
24925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24926       };
24927     } catch (std::exception& e) {
24928       {
24929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24930       };
24931     } catch (Dali::DaliException e) {
24932       {
24933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24934       };
24935     } catch (...) {
24936       {
24937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24938       };
24939     }
24940   }
24941
24942   jresult = (void *)result;
24943   return jresult;
24944 }
24945
24946
24947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24948   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24949   Dali::FilterMode::Type arg2 ;
24950   Dali::FilterMode::Type arg3 ;
24951
24952   arg1 = (Dali::Sampler *)jarg1;
24953   arg2 = (Dali::FilterMode::Type)jarg2;
24954   arg3 = (Dali::FilterMode::Type)jarg3;
24955   {
24956     try {
24957       (arg1)->SetFilterMode(arg2,arg3);
24958     } catch (std::out_of_range& e) {
24959       {
24960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24961       };
24962     } catch (std::exception& e) {
24963       {
24964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24965       };
24966     } catch (Dali::DaliException e) {
24967       {
24968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24969       };
24970     } catch (...) {
24971       {
24972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24973       };
24974     }
24975   }
24976
24977 }
24978
24979
24980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24981   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24982   Dali::WrapMode::Type arg2 ;
24983   Dali::WrapMode::Type arg3 ;
24984
24985   arg1 = (Dali::Sampler *)jarg1;
24986   arg2 = (Dali::WrapMode::Type)jarg2;
24987   arg3 = (Dali::WrapMode::Type)jarg3;
24988   {
24989     try {
24990       (arg1)->SetWrapMode(arg2,arg3);
24991     } catch (std::out_of_range& e) {
24992       {
24993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24994       };
24995     } catch (std::exception& e) {
24996       {
24997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24998       };
24999     } catch (Dali::DaliException e) {
25000       {
25001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25002       };
25003     } catch (...) {
25004       {
25005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25006       };
25007     }
25008   }
25009
25010 }
25011
25012
25013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25014   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25015   Dali::WrapMode::Type arg2 ;
25016   Dali::WrapMode::Type arg3 ;
25017   Dali::WrapMode::Type arg4 ;
25018
25019   arg1 = (Dali::Sampler *)jarg1;
25020   arg2 = (Dali::WrapMode::Type)jarg2;
25021   arg3 = (Dali::WrapMode::Type)jarg3;
25022   arg4 = (Dali::WrapMode::Type)jarg4;
25023   {
25024     try {
25025       (arg1)->SetWrapMode(arg2,arg3,arg4);
25026     } catch (std::out_of_range& e) {
25027       {
25028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25029       };
25030     } catch (std::exception& e) {
25031       {
25032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25033       };
25034     } catch (Dali::DaliException e) {
25035       {
25036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25037       };
25038     } catch (...) {
25039       {
25040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25041       };
25042     }
25043   }
25044
25045 }
25046
25047
25048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25049   void * jresult ;
25050   Dali::TextureSet result;
25051
25052   {
25053     try {
25054       result = Dali::TextureSet::New();
25055     } catch (std::out_of_range& e) {
25056       {
25057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25058       };
25059     } catch (std::exception& e) {
25060       {
25061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25062       };
25063     } catch (Dali::DaliException e) {
25064       {
25065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25066       };
25067     } catch (...) {
25068       {
25069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25070       };
25071     }
25072   }
25073
25074   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25075   return jresult;
25076 }
25077
25078
25079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25080   void * jresult ;
25081   Dali::TextureSet *result = 0 ;
25082
25083   {
25084     try {
25085       result = (Dali::TextureSet *)new Dali::TextureSet();
25086     } catch (std::out_of_range& e) {
25087       {
25088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25089       };
25090     } catch (std::exception& e) {
25091       {
25092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25093       };
25094     } catch (Dali::DaliException e) {
25095       {
25096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25097       };
25098     } catch (...) {
25099       {
25100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25101       };
25102     }
25103   }
25104
25105   jresult = (void *)result;
25106   return jresult;
25107 }
25108
25109
25110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25111   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25112
25113   arg1 = (Dali::TextureSet *)jarg1;
25114   {
25115     try {
25116       delete arg1;
25117     } catch (std::out_of_range& e) {
25118       {
25119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25120       };
25121     } catch (std::exception& e) {
25122       {
25123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25124       };
25125     } catch (Dali::DaliException e) {
25126       {
25127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25128       };
25129     } catch (...) {
25130       {
25131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25132       };
25133     }
25134   }
25135
25136 }
25137
25138
25139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25140   void * jresult ;
25141   Dali::TextureSet *arg1 = 0 ;
25142   Dali::TextureSet *result = 0 ;
25143
25144   arg1 = (Dali::TextureSet *)jarg1;
25145   if (!arg1) {
25146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25147     return 0;
25148   }
25149   {
25150     try {
25151       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25152     } catch (std::out_of_range& e) {
25153       {
25154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25155       };
25156     } catch (std::exception& e) {
25157       {
25158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25159       };
25160     } catch (Dali::DaliException e) {
25161       {
25162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25163       };
25164     } catch (...) {
25165       {
25166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25167       };
25168     }
25169   }
25170
25171   jresult = (void *)result;
25172   return jresult;
25173 }
25174
25175
25176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25177   void * jresult ;
25178   Dali::BaseHandle arg1 ;
25179   Dali::BaseHandle *argp1 ;
25180   Dali::TextureSet result;
25181
25182   argp1 = (Dali::BaseHandle *)jarg1;
25183   if (!argp1) {
25184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25185     return 0;
25186   }
25187   arg1 = *argp1;
25188   {
25189     try {
25190       result = Dali::TextureSet::DownCast(arg1);
25191     } catch (std::out_of_range& e) {
25192       {
25193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25194       };
25195     } catch (std::exception& e) {
25196       {
25197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25198       };
25199     } catch (Dali::DaliException e) {
25200       {
25201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25202       };
25203     } catch (...) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25206       };
25207     }
25208   }
25209
25210   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25211   return jresult;
25212 }
25213
25214
25215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25216   void * jresult ;
25217   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25218   Dali::TextureSet *arg2 = 0 ;
25219   Dali::TextureSet *result = 0 ;
25220
25221   arg1 = (Dali::TextureSet *)jarg1;
25222   arg2 = (Dali::TextureSet *)jarg2;
25223   if (!arg2) {
25224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25225     return 0;
25226   }
25227   {
25228     try {
25229       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25230     } catch (std::out_of_range& e) {
25231       {
25232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25233       };
25234     } catch (std::exception& e) {
25235       {
25236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25237       };
25238     } catch (Dali::DaliException e) {
25239       {
25240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25241       };
25242     } catch (...) {
25243       {
25244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25245       };
25246     }
25247   }
25248
25249   jresult = (void *)result;
25250   return jresult;
25251 }
25252
25253
25254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25255   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25256   size_t arg2 ;
25257   Dali::Texture arg3 ;
25258   Dali::Texture *argp3 ;
25259
25260   arg1 = (Dali::TextureSet *)jarg1;
25261   arg2 = (size_t)jarg2;
25262   argp3 = (Dali::Texture *)jarg3;
25263   if (!argp3) {
25264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25265     return ;
25266   }
25267   arg3 = *argp3;
25268   {
25269     try {
25270       (arg1)->SetTexture(arg2,arg3);
25271     } catch (std::out_of_range& e) {
25272       {
25273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25274       };
25275     } catch (std::exception& e) {
25276       {
25277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25278       };
25279     } catch (Dali::DaliException e) {
25280       {
25281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25282       };
25283     } catch (...) {
25284       {
25285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25286       };
25287     }
25288   }
25289
25290 }
25291
25292
25293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25294   void * jresult ;
25295   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25296   size_t arg2 ;
25297   Dali::Texture result;
25298
25299   arg1 = (Dali::TextureSet *)jarg1;
25300   arg2 = (size_t)jarg2;
25301   {
25302     try {
25303       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25304     } catch (std::out_of_range& e) {
25305       {
25306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25307       };
25308     } catch (std::exception& e) {
25309       {
25310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25311       };
25312     } catch (Dali::DaliException e) {
25313       {
25314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25315       };
25316     } catch (...) {
25317       {
25318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25319       };
25320     }
25321   }
25322
25323   jresult = new Dali::Texture((const Dali::Texture &)result);
25324   return jresult;
25325 }
25326
25327
25328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25329   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25330   size_t arg2 ;
25331   Dali::Sampler arg3 ;
25332   Dali::Sampler *argp3 ;
25333
25334   arg1 = (Dali::TextureSet *)jarg1;
25335   arg2 = (size_t)jarg2;
25336   argp3 = (Dali::Sampler *)jarg3;
25337   if (!argp3) {
25338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25339     return ;
25340   }
25341   arg3 = *argp3;
25342   {
25343     try {
25344       (arg1)->SetSampler(arg2,arg3);
25345     } catch (std::out_of_range& e) {
25346       {
25347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25348       };
25349     } catch (std::exception& e) {
25350       {
25351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25352       };
25353     } catch (Dali::DaliException e) {
25354       {
25355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25356       };
25357     } catch (...) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25360       };
25361     }
25362   }
25363
25364 }
25365
25366
25367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25368   void * jresult ;
25369   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25370   size_t arg2 ;
25371   Dali::Sampler result;
25372
25373   arg1 = (Dali::TextureSet *)jarg1;
25374   arg2 = (size_t)jarg2;
25375   {
25376     try {
25377       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25378     } catch (std::out_of_range& e) {
25379       {
25380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25381       };
25382     } catch (std::exception& e) {
25383       {
25384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25385       };
25386     } catch (Dali::DaliException e) {
25387       {
25388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25389       };
25390     } catch (...) {
25391       {
25392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25393       };
25394     }
25395   }
25396
25397   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25398   return jresult;
25399 }
25400
25401
25402 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25403   unsigned long jresult ;
25404   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25405   size_t result;
25406
25407   arg1 = (Dali::TextureSet *)jarg1;
25408   {
25409     try {
25410       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25411     } catch (std::out_of_range& e) {
25412       {
25413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25414       };
25415     } catch (std::exception& e) {
25416       {
25417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25418       };
25419     } catch (Dali::DaliException e) {
25420       {
25421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25422       };
25423     } catch (...) {
25424       {
25425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25426       };
25427     }
25428   }
25429
25430   jresult = (unsigned long)result;
25431   return jresult;
25432 }
25433
25434
25435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25436   void * jresult ;
25437   Dali::Property::Map *arg1 = 0 ;
25438   Dali::PropertyBuffer result;
25439
25440   arg1 = (Dali::Property::Map *)jarg1;
25441   if (!arg1) {
25442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25443     return 0;
25444   }
25445   {
25446     try {
25447       result = Dali::PropertyBuffer::New(*arg1);
25448     } catch (std::out_of_range& e) {
25449       {
25450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25451       };
25452     } catch (std::exception& e) {
25453       {
25454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25455       };
25456     } catch (Dali::DaliException e) {
25457       {
25458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25459       };
25460     } catch (...) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25463       };
25464     }
25465   }
25466
25467   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25468   return jresult;
25469 }
25470
25471
25472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25473   void * jresult ;
25474   Dali::PropertyBuffer *result = 0 ;
25475
25476   {
25477     try {
25478       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25479     } catch (std::out_of_range& e) {
25480       {
25481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25482       };
25483     } catch (std::exception& e) {
25484       {
25485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25486       };
25487     } catch (Dali::DaliException e) {
25488       {
25489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25490       };
25491     } catch (...) {
25492       {
25493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25494       };
25495     }
25496   }
25497
25498   jresult = (void *)result;
25499   return jresult;
25500 }
25501
25502
25503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25504   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25505
25506   arg1 = (Dali::PropertyBuffer *)jarg1;
25507   {
25508     try {
25509       delete arg1;
25510     } catch (std::out_of_range& e) {
25511       {
25512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25513       };
25514     } catch (std::exception& e) {
25515       {
25516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25517       };
25518     } catch (Dali::DaliException e) {
25519       {
25520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25521       };
25522     } catch (...) {
25523       {
25524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25525       };
25526     }
25527   }
25528
25529 }
25530
25531
25532 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25533   void * jresult ;
25534   Dali::PropertyBuffer *arg1 = 0 ;
25535   Dali::PropertyBuffer *result = 0 ;
25536
25537   arg1 = (Dali::PropertyBuffer *)jarg1;
25538   if (!arg1) {
25539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25540     return 0;
25541   }
25542   {
25543     try {
25544       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25545     } catch (std::out_of_range& e) {
25546       {
25547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25548       };
25549     } catch (std::exception& e) {
25550       {
25551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25552       };
25553     } catch (Dali::DaliException e) {
25554       {
25555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25556       };
25557     } catch (...) {
25558       {
25559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25560       };
25561     }
25562   }
25563
25564   jresult = (void *)result;
25565   return jresult;
25566 }
25567
25568
25569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25570   void * jresult ;
25571   Dali::BaseHandle arg1 ;
25572   Dali::BaseHandle *argp1 ;
25573   Dali::PropertyBuffer result;
25574
25575   argp1 = (Dali::BaseHandle *)jarg1;
25576   if (!argp1) {
25577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25578     return 0;
25579   }
25580   arg1 = *argp1;
25581   {
25582     try {
25583       result = Dali::PropertyBuffer::DownCast(arg1);
25584     } catch (std::out_of_range& e) {
25585       {
25586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25587       };
25588     } catch (std::exception& e) {
25589       {
25590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25591       };
25592     } catch (Dali::DaliException e) {
25593       {
25594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25595       };
25596     } catch (...) {
25597       {
25598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25599       };
25600     }
25601   }
25602
25603   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25604   return jresult;
25605 }
25606
25607
25608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25609   void * jresult ;
25610   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25611   Dali::PropertyBuffer *arg2 = 0 ;
25612   Dali::PropertyBuffer *result = 0 ;
25613
25614   arg1 = (Dali::PropertyBuffer *)jarg1;
25615   arg2 = (Dali::PropertyBuffer *)jarg2;
25616   if (!arg2) {
25617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25618     return 0;
25619   }
25620   {
25621     try {
25622       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25623     } catch (std::out_of_range& e) {
25624       {
25625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25626       };
25627     } catch (std::exception& e) {
25628       {
25629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25630       };
25631     } catch (Dali::DaliException e) {
25632       {
25633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25634       };
25635     } catch (...) {
25636       {
25637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25638       };
25639     }
25640   }
25641
25642   jresult = (void *)result;
25643   return jresult;
25644 }
25645
25646
25647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25648   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25649   void *arg2 = (void *) 0 ;
25650   std::size_t arg3 ;
25651
25652   arg1 = (Dali::PropertyBuffer *)jarg1;
25653   arg2 = jarg2;
25654   arg3 = (std::size_t)jarg3;
25655   {
25656     try {
25657       (arg1)->SetData((void const *)arg2,arg3);
25658     } catch (std::out_of_range& e) {
25659       {
25660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25661       };
25662     } catch (std::exception& e) {
25663       {
25664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25665       };
25666     } catch (Dali::DaliException e) {
25667       {
25668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25669       };
25670     } catch (...) {
25671       {
25672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25673       };
25674     }
25675   }
25676
25677 }
25678
25679
25680 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25681   unsigned long jresult ;
25682   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25683   std::size_t result;
25684
25685   arg1 = (Dali::PropertyBuffer *)jarg1;
25686   {
25687     try {
25688       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25689     } catch (std::out_of_range& e) {
25690       {
25691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25692       };
25693     } catch (std::exception& e) {
25694       {
25695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25696       };
25697     } catch (Dali::DaliException e) {
25698       {
25699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25700       };
25701     } catch (...) {
25702       {
25703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25704       };
25705     }
25706   }
25707
25708   jresult = (unsigned long)result;
25709   return jresult;
25710 }
25711
25712
25713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25714   void * jresult ;
25715   Dali::Geometry result;
25716
25717   {
25718     try {
25719       result = Dali::Geometry::New();
25720     } catch (std::out_of_range& e) {
25721       {
25722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25723       };
25724     } catch (std::exception& e) {
25725       {
25726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25727       };
25728     } catch (Dali::DaliException e) {
25729       {
25730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25731       };
25732     } catch (...) {
25733       {
25734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25735       };
25736     }
25737   }
25738
25739   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25740   return jresult;
25741 }
25742
25743
25744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25745   void * jresult ;
25746   Dali::Geometry *result = 0 ;
25747
25748   {
25749     try {
25750       result = (Dali::Geometry *)new Dali::Geometry();
25751     } catch (std::out_of_range& e) {
25752       {
25753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25754       };
25755     } catch (std::exception& e) {
25756       {
25757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25758       };
25759     } catch (Dali::DaliException e) {
25760       {
25761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25762       };
25763     } catch (...) {
25764       {
25765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25766       };
25767     }
25768   }
25769
25770   jresult = (void *)result;
25771   return jresult;
25772 }
25773
25774
25775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25776   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25777
25778   arg1 = (Dali::Geometry *)jarg1;
25779   {
25780     try {
25781       delete arg1;
25782     } catch (std::out_of_range& e) {
25783       {
25784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25785       };
25786     } catch (std::exception& e) {
25787       {
25788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25789       };
25790     } catch (Dali::DaliException e) {
25791       {
25792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25793       };
25794     } catch (...) {
25795       {
25796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25797       };
25798     }
25799   }
25800
25801 }
25802
25803
25804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25805   void * jresult ;
25806   Dali::Geometry *arg1 = 0 ;
25807   Dali::Geometry *result = 0 ;
25808
25809   arg1 = (Dali::Geometry *)jarg1;
25810   if (!arg1) {
25811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25812     return 0;
25813   }
25814   {
25815     try {
25816       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25817     } catch (std::out_of_range& e) {
25818       {
25819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25820       };
25821     } catch (std::exception& e) {
25822       {
25823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25824       };
25825     } catch (Dali::DaliException e) {
25826       {
25827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25828       };
25829     } catch (...) {
25830       {
25831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25832       };
25833     }
25834   }
25835
25836   jresult = (void *)result;
25837   return jresult;
25838 }
25839
25840
25841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25842   void * jresult ;
25843   Dali::BaseHandle arg1 ;
25844   Dali::BaseHandle *argp1 ;
25845   Dali::Geometry result;
25846
25847   argp1 = (Dali::BaseHandle *)jarg1;
25848   if (!argp1) {
25849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25850     return 0;
25851   }
25852   arg1 = *argp1;
25853   {
25854     try {
25855       result = Dali::Geometry::DownCast(arg1);
25856     } catch (std::out_of_range& e) {
25857       {
25858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25859       };
25860     } catch (std::exception& e) {
25861       {
25862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25863       };
25864     } catch (Dali::DaliException e) {
25865       {
25866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25867       };
25868     } catch (...) {
25869       {
25870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25871       };
25872     }
25873   }
25874
25875   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25876   return jresult;
25877 }
25878
25879
25880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25881   void * jresult ;
25882   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25883   Dali::Geometry *arg2 = 0 ;
25884   Dali::Geometry *result = 0 ;
25885
25886   arg1 = (Dali::Geometry *)jarg1;
25887   arg2 = (Dali::Geometry *)jarg2;
25888   if (!arg2) {
25889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25890     return 0;
25891   }
25892   {
25893     try {
25894       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25895     } catch (std::out_of_range& e) {
25896       {
25897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25898       };
25899     } catch (std::exception& e) {
25900       {
25901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25902       };
25903     } catch (Dali::DaliException e) {
25904       {
25905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25906       };
25907     } catch (...) {
25908       {
25909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25910       };
25911     }
25912   }
25913
25914   jresult = (void *)result;
25915   return jresult;
25916 }
25917
25918
25919 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25920   unsigned long jresult ;
25921   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25922   Dali::PropertyBuffer *arg2 = 0 ;
25923   std::size_t result;
25924
25925   arg1 = (Dali::Geometry *)jarg1;
25926   arg2 = (Dali::PropertyBuffer *)jarg2;
25927   if (!arg2) {
25928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25929     return 0;
25930   }
25931   {
25932     try {
25933       result = (arg1)->AddVertexBuffer(*arg2);
25934     } catch (std::out_of_range& e) {
25935       {
25936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25937       };
25938     } catch (std::exception& e) {
25939       {
25940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25941       };
25942     } catch (Dali::DaliException e) {
25943       {
25944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25945       };
25946     } catch (...) {
25947       {
25948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25949       };
25950     }
25951   }
25952
25953   jresult = (unsigned long)result;
25954   return jresult;
25955 }
25956
25957
25958 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25959   unsigned long jresult ;
25960   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25961   std::size_t result;
25962
25963   arg1 = (Dali::Geometry *)jarg1;
25964   {
25965     try {
25966       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25967     } catch (std::out_of_range& e) {
25968       {
25969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25970       };
25971     } catch (std::exception& e) {
25972       {
25973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25974       };
25975     } catch (Dali::DaliException e) {
25976       {
25977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25978       };
25979     } catch (...) {
25980       {
25981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25982       };
25983     }
25984   }
25985
25986   jresult = (unsigned long)result;
25987   return jresult;
25988 }
25989
25990
25991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25992   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25993   std::size_t arg2 ;
25994
25995   arg1 = (Dali::Geometry *)jarg1;
25996   arg2 = (std::size_t)jarg2;
25997   {
25998     try {
25999       (arg1)->RemoveVertexBuffer(arg2);
26000     } catch (std::out_of_range& e) {
26001       {
26002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26003       };
26004     } catch (std::exception& e) {
26005       {
26006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26007       };
26008     } catch (Dali::DaliException e) {
26009       {
26010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26011       };
26012     } catch (...) {
26013       {
26014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26015       };
26016     }
26017   }
26018
26019 }
26020
26021
26022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26023   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26024   unsigned short *arg2 = (unsigned short *) 0 ;
26025   size_t arg3 ;
26026
26027   arg1 = (Dali::Geometry *)jarg1;
26028   arg2 = jarg2;
26029   arg3 = (size_t)jarg3;
26030   {
26031     try {
26032       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26033     } catch (std::out_of_range& e) {
26034       {
26035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26036       };
26037     } catch (std::exception& e) {
26038       {
26039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26040       };
26041     } catch (Dali::DaliException e) {
26042       {
26043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26044       };
26045     } catch (...) {
26046       {
26047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26048       };
26049     }
26050   }
26051
26052
26053
26054 }
26055
26056
26057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26058   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26059   Dali::Geometry::Type arg2 ;
26060
26061   arg1 = (Dali::Geometry *)jarg1;
26062   arg2 = (Dali::Geometry::Type)jarg2;
26063   {
26064     try {
26065       (arg1)->SetType(arg2);
26066     } catch (std::out_of_range& e) {
26067       {
26068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26069       };
26070     } catch (std::exception& e) {
26071       {
26072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26073       };
26074     } catch (Dali::DaliException e) {
26075       {
26076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26077       };
26078     } catch (...) {
26079       {
26080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26081       };
26082     }
26083   }
26084
26085 }
26086
26087
26088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26089   int jresult ;
26090   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26091   Dali::Geometry::Type result;
26092
26093   arg1 = (Dali::Geometry *)jarg1;
26094   {
26095     try {
26096       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26097     } catch (std::out_of_range& e) {
26098       {
26099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26100       };
26101     } catch (std::exception& e) {
26102       {
26103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26104       };
26105     } catch (Dali::DaliException e) {
26106       {
26107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26108       };
26109     } catch (...) {
26110       {
26111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26112       };
26113     }
26114   }
26115
26116   jresult = (int)result;
26117   return jresult;
26118 }
26119
26120
26121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26122   void * jresult ;
26123   Dali::Shader::Hint *result = 0 ;
26124
26125   {
26126     try {
26127       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26128     } catch (std::out_of_range& e) {
26129       {
26130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26131       };
26132     } catch (std::exception& e) {
26133       {
26134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26135       };
26136     } catch (Dali::DaliException e) {
26137       {
26138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26139       };
26140     } catch (...) {
26141       {
26142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26143       };
26144     }
26145   }
26146
26147   jresult = (void *)result;
26148   return jresult;
26149 }
26150
26151
26152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26153   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26154
26155   arg1 = (Dali::Shader::Hint *)jarg1;
26156   {
26157     try {
26158       delete arg1;
26159     } catch (std::out_of_range& e) {
26160       {
26161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26162       };
26163     } catch (std::exception& e) {
26164       {
26165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26166       };
26167     } catch (Dali::DaliException e) {
26168       {
26169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26170       };
26171     } catch (...) {
26172       {
26173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26174       };
26175     }
26176   }
26177
26178 }
26179
26180
26181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26182   int jresult ;
26183   int result;
26184
26185   result = (int)Dali::Shader::Property::PROGRAM;
26186   jresult = (int)result;
26187   return jresult;
26188 }
26189
26190
26191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26192   void * jresult ;
26193   Dali::Shader::Property *result = 0 ;
26194
26195   {
26196     try {
26197       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26198     } catch (std::out_of_range& e) {
26199       {
26200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26201       };
26202     } catch (std::exception& e) {
26203       {
26204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (Dali::DaliException e) {
26207       {
26208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26209       };
26210     } catch (...) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26213       };
26214     }
26215   }
26216
26217   jresult = (void *)result;
26218   return jresult;
26219 }
26220
26221
26222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26223   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26224
26225   arg1 = (Dali::Shader::Property *)jarg1;
26226   {
26227     try {
26228       delete arg1;
26229     } catch (std::out_of_range& e) {
26230       {
26231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26232       };
26233     } catch (std::exception& e) {
26234       {
26235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26236       };
26237     } catch (Dali::DaliException e) {
26238       {
26239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26240       };
26241     } catch (...) {
26242       {
26243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26244       };
26245     }
26246   }
26247
26248 }
26249
26250
26251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26252   void * jresult ;
26253   std::string *arg1 = 0 ;
26254   std::string *arg2 = 0 ;
26255   Dali::Shader::Hint::Value arg3 ;
26256   Dali::Shader result;
26257
26258   if (!jarg1) {
26259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26260     return 0;
26261   }
26262   std::string arg1_str(jarg1);
26263   arg1 = &arg1_str;
26264   if (!jarg2) {
26265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26266     return 0;
26267   }
26268   std::string arg2_str(jarg2);
26269   arg2 = &arg2_str;
26270   arg3 = (Dali::Shader::Hint::Value)jarg3;
26271   {
26272     try {
26273       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26274     } catch (std::out_of_range& e) {
26275       {
26276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26277       };
26278     } catch (std::exception& e) {
26279       {
26280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26281       };
26282     } catch (Dali::DaliException e) {
26283       {
26284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26285       };
26286     } catch (...) {
26287       {
26288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26289       };
26290     }
26291   }
26292
26293   jresult = new Dali::Shader((const Dali::Shader &)result);
26294
26295   //argout typemap for const std::string&
26296
26297
26298   //argout typemap for const std::string&
26299
26300   return jresult;
26301 }
26302
26303
26304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26305   void * jresult ;
26306   std::string *arg1 = 0 ;
26307   std::string *arg2 = 0 ;
26308   Dali::Shader result;
26309
26310   if (!jarg1) {
26311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26312     return 0;
26313   }
26314   std::string arg1_str(jarg1);
26315   arg1 = &arg1_str;
26316   if (!jarg2) {
26317     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26318     return 0;
26319   }
26320   std::string arg2_str(jarg2);
26321   arg2 = &arg2_str;
26322   {
26323     try {
26324       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26325     } catch (std::out_of_range& e) {
26326       {
26327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26328       };
26329     } catch (std::exception& e) {
26330       {
26331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26332       };
26333     } catch (Dali::DaliException e) {
26334       {
26335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26336       };
26337     } catch (...) {
26338       {
26339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26340       };
26341     }
26342   }
26343
26344   jresult = new Dali::Shader((const Dali::Shader &)result);
26345
26346   //argout typemap for const std::string&
26347
26348
26349   //argout typemap for const std::string&
26350
26351   return jresult;
26352 }
26353
26354
26355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26356   void * jresult ;
26357   Dali::Shader *result = 0 ;
26358
26359   {
26360     try {
26361       result = (Dali::Shader *)new Dali::Shader();
26362     } catch (std::out_of_range& e) {
26363       {
26364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26365       };
26366     } catch (std::exception& e) {
26367       {
26368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26369       };
26370     } catch (Dali::DaliException e) {
26371       {
26372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26373       };
26374     } catch (...) {
26375       {
26376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26377       };
26378     }
26379   }
26380
26381   jresult = (void *)result;
26382   return jresult;
26383 }
26384
26385
26386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26387   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26388
26389   arg1 = (Dali::Shader *)jarg1;
26390   {
26391     try {
26392       delete arg1;
26393     } catch (std::out_of_range& e) {
26394       {
26395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26396       };
26397     } catch (std::exception& e) {
26398       {
26399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26400       };
26401     } catch (Dali::DaliException e) {
26402       {
26403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26404       };
26405     } catch (...) {
26406       {
26407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26408       };
26409     }
26410   }
26411
26412 }
26413
26414
26415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26416   void * jresult ;
26417   Dali::Shader *arg1 = 0 ;
26418   Dali::Shader *result = 0 ;
26419
26420   arg1 = (Dali::Shader *)jarg1;
26421   if (!arg1) {
26422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26423     return 0;
26424   }
26425   {
26426     try {
26427       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26428     } catch (std::out_of_range& e) {
26429       {
26430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26431       };
26432     } catch (std::exception& e) {
26433       {
26434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26435       };
26436     } catch (Dali::DaliException e) {
26437       {
26438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26439       };
26440     } catch (...) {
26441       {
26442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26443       };
26444     }
26445   }
26446
26447   jresult = (void *)result;
26448   return jresult;
26449 }
26450
26451
26452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26453   void * jresult ;
26454   Dali::BaseHandle arg1 ;
26455   Dali::BaseHandle *argp1 ;
26456   Dali::Shader result;
26457
26458   argp1 = (Dali::BaseHandle *)jarg1;
26459   if (!argp1) {
26460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26461     return 0;
26462   }
26463   arg1 = *argp1;
26464   {
26465     try {
26466       result = Dali::Shader::DownCast(arg1);
26467     } catch (std::out_of_range& e) {
26468       {
26469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26470       };
26471     } catch (std::exception& e) {
26472       {
26473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26474       };
26475     } catch (Dali::DaliException e) {
26476       {
26477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26478       };
26479     } catch (...) {
26480       {
26481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26482       };
26483     }
26484   }
26485
26486   jresult = new Dali::Shader((const Dali::Shader &)result);
26487   return jresult;
26488 }
26489
26490
26491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26492   void * jresult ;
26493   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26494   Dali::Shader *arg2 = 0 ;
26495   Dali::Shader *result = 0 ;
26496
26497   arg1 = (Dali::Shader *)jarg1;
26498   arg2 = (Dali::Shader *)jarg2;
26499   if (!arg2) {
26500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26501     return 0;
26502   }
26503   {
26504     try {
26505       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26506     } catch (std::out_of_range& e) {
26507       {
26508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26509       };
26510     } catch (std::exception& e) {
26511       {
26512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26513       };
26514     } catch (Dali::DaliException e) {
26515       {
26516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26517       };
26518     } catch (...) {
26519       {
26520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26521       };
26522     }
26523   }
26524
26525   jresult = (void *)result;
26526   return jresult;
26527 }
26528
26529
26530 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26531   int jresult ;
26532   int result;
26533
26534   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26535   jresult = (int)result;
26536   return jresult;
26537 }
26538
26539
26540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26541   int jresult ;
26542   int result;
26543
26544   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26545   jresult = (int)result;
26546   return jresult;
26547 }
26548
26549
26550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26551   int jresult ;
26552   int result;
26553
26554   result = (int)Dali::Renderer::Property::BLEND_MODE;
26555   jresult = (int)result;
26556   return jresult;
26557 }
26558
26559
26560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26561   int jresult ;
26562   int result;
26563
26564   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26565   jresult = (int)result;
26566   return jresult;
26567 }
26568
26569
26570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26571   int jresult ;
26572   int result;
26573
26574   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26575   jresult = (int)result;
26576   return jresult;
26577 }
26578
26579
26580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26581   int jresult ;
26582   int result;
26583
26584   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26585   jresult = (int)result;
26586   return jresult;
26587 }
26588
26589
26590 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26591   int jresult ;
26592   int result;
26593
26594   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26595   jresult = (int)result;
26596   return jresult;
26597 }
26598
26599
26600 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26601   int jresult ;
26602   int result;
26603
26604   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26605   jresult = (int)result;
26606   return jresult;
26607 }
26608
26609
26610 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26611   int jresult ;
26612   int result;
26613
26614   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26615   jresult = (int)result;
26616   return jresult;
26617 }
26618
26619
26620 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26621   int jresult ;
26622   int result;
26623
26624   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26625   jresult = (int)result;
26626   return jresult;
26627 }
26628
26629
26630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26631   int jresult ;
26632   int result;
26633
26634   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26635   jresult = (int)result;
26636   return jresult;
26637 }
26638
26639
26640 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26641   int jresult ;
26642   int result;
26643
26644   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26645   jresult = (int)result;
26646   return jresult;
26647 }
26648
26649
26650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26651   int jresult ;
26652   int result;
26653
26654   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26655   jresult = (int)result;
26656   return jresult;
26657 }
26658
26659
26660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26661   int jresult ;
26662   int result;
26663
26664   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26665   jresult = (int)result;
26666   return jresult;
26667 }
26668
26669
26670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26671   int jresult ;
26672   int result;
26673
26674   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26675   jresult = (int)result;
26676   return jresult;
26677 }
26678
26679
26680 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26681   int jresult ;
26682   int result;
26683
26684   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26685   jresult = (int)result;
26686   return jresult;
26687 }
26688
26689
26690 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26691   int jresult ;
26692   int result;
26693
26694   result = (int)Dali::Renderer::Property::RENDER_MODE;
26695   jresult = (int)result;
26696   return jresult;
26697 }
26698
26699
26700 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26701   int jresult ;
26702   int result;
26703
26704   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26705   jresult = (int)result;
26706   return jresult;
26707 }
26708
26709
26710 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26711   int jresult ;
26712   int result;
26713
26714   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26715   jresult = (int)result;
26716   return jresult;
26717 }
26718
26719
26720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26721   int jresult ;
26722   int result;
26723
26724   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26725   jresult = (int)result;
26726   return jresult;
26727 }
26728
26729
26730 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26731   int jresult ;
26732   int result;
26733
26734   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26735   jresult = (int)result;
26736   return jresult;
26737 }
26738
26739
26740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26741   int jresult ;
26742   int result;
26743
26744   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26745   jresult = (int)result;
26746   return jresult;
26747 }
26748
26749
26750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26751   int jresult ;
26752   int result;
26753
26754   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26755   jresult = (int)result;
26756   return jresult;
26757 }
26758
26759
26760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26761   int jresult ;
26762   int result;
26763
26764   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26765   jresult = (int)result;
26766   return jresult;
26767 }
26768
26769
26770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26771   void * jresult ;
26772   Dali::Renderer::Property *result = 0 ;
26773
26774   {
26775     try {
26776       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26777     } catch (std::out_of_range& e) {
26778       {
26779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26780       };
26781     } catch (std::exception& e) {
26782       {
26783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26784       };
26785     } catch (Dali::DaliException e) {
26786       {
26787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26788       };
26789     } catch (...) {
26790       {
26791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26792       };
26793     }
26794   }
26795
26796   jresult = (void *)result;
26797   return jresult;
26798 }
26799
26800
26801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26802   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26803
26804   arg1 = (Dali::Renderer::Property *)jarg1;
26805   {
26806     try {
26807       delete arg1;
26808     } catch (std::out_of_range& e) {
26809       {
26810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26811       };
26812     } catch (std::exception& e) {
26813       {
26814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26815       };
26816     } catch (Dali::DaliException e) {
26817       {
26818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26819       };
26820     } catch (...) {
26821       {
26822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26823       };
26824     }
26825   }
26826
26827 }
26828
26829
26830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26831   void * jresult ;
26832   Dali::Geometry *arg1 = 0 ;
26833   Dali::Shader *arg2 = 0 ;
26834   Dali::Renderer result;
26835
26836   arg1 = (Dali::Geometry *)jarg1;
26837   if (!arg1) {
26838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26839     return 0;
26840   }
26841   arg2 = (Dali::Shader *)jarg2;
26842   if (!arg2) {
26843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26844     return 0;
26845   }
26846   {
26847     try {
26848       result = Dali::Renderer::New(*arg1,*arg2);
26849     } catch (std::out_of_range& e) {
26850       {
26851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26852       };
26853     } catch (std::exception& e) {
26854       {
26855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26856       };
26857     } catch (Dali::DaliException e) {
26858       {
26859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26860       };
26861     } catch (...) {
26862       {
26863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26864       };
26865     }
26866   }
26867
26868   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26869   return jresult;
26870 }
26871
26872
26873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26874   void * jresult ;
26875   Dali::Renderer *result = 0 ;
26876
26877   {
26878     try {
26879       result = (Dali::Renderer *)new Dali::Renderer();
26880     } catch (std::out_of_range& e) {
26881       {
26882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26883       };
26884     } catch (std::exception& e) {
26885       {
26886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26887       };
26888     } catch (Dali::DaliException e) {
26889       {
26890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26891       };
26892     } catch (...) {
26893       {
26894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26895       };
26896     }
26897   }
26898
26899   jresult = (void *)result;
26900   return jresult;
26901 }
26902
26903
26904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26905   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26906
26907   arg1 = (Dali::Renderer *)jarg1;
26908   {
26909     try {
26910       delete arg1;
26911     } catch (std::out_of_range& e) {
26912       {
26913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26914       };
26915     } catch (std::exception& e) {
26916       {
26917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26918       };
26919     } catch (Dali::DaliException e) {
26920       {
26921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26922       };
26923     } catch (...) {
26924       {
26925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26926       };
26927     }
26928   }
26929
26930 }
26931
26932
26933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26934   void * jresult ;
26935   Dali::Renderer *arg1 = 0 ;
26936   Dali::Renderer *result = 0 ;
26937
26938   arg1 = (Dali::Renderer *)jarg1;
26939   if (!arg1) {
26940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26941     return 0;
26942   }
26943   {
26944     try {
26945       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26946     } catch (std::out_of_range& e) {
26947       {
26948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26949       };
26950     } catch (std::exception& e) {
26951       {
26952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26953       };
26954     } catch (Dali::DaliException e) {
26955       {
26956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26957       };
26958     } catch (...) {
26959       {
26960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26961       };
26962     }
26963   }
26964
26965   jresult = (void *)result;
26966   return jresult;
26967 }
26968
26969
26970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26971   void * jresult ;
26972   Dali::BaseHandle arg1 ;
26973   Dali::BaseHandle *argp1 ;
26974   Dali::Renderer result;
26975
26976   argp1 = (Dali::BaseHandle *)jarg1;
26977   if (!argp1) {
26978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26979     return 0;
26980   }
26981   arg1 = *argp1;
26982   {
26983     try {
26984       result = Dali::Renderer::DownCast(arg1);
26985     } catch (std::out_of_range& e) {
26986       {
26987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26988       };
26989     } catch (std::exception& e) {
26990       {
26991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26992       };
26993     } catch (Dali::DaliException e) {
26994       {
26995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26996       };
26997     } catch (...) {
26998       {
26999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27000       };
27001     }
27002   }
27003
27004   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27005   return jresult;
27006 }
27007
27008
27009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27010   void * jresult ;
27011   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27012   Dali::Renderer *arg2 = 0 ;
27013   Dali::Renderer *result = 0 ;
27014
27015   arg1 = (Dali::Renderer *)jarg1;
27016   arg2 = (Dali::Renderer *)jarg2;
27017   if (!arg2) {
27018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27019     return 0;
27020   }
27021   {
27022     try {
27023       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
27024     } catch (std::out_of_range& e) {
27025       {
27026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27027       };
27028     } catch (std::exception& e) {
27029       {
27030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27031       };
27032     } catch (Dali::DaliException e) {
27033       {
27034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27035       };
27036     } catch (...) {
27037       {
27038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27039       };
27040     }
27041   }
27042
27043   jresult = (void *)result;
27044   return jresult;
27045 }
27046
27047
27048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27049   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27050   Dali::Geometry *arg2 = 0 ;
27051
27052   arg1 = (Dali::Renderer *)jarg1;
27053   arg2 = (Dali::Geometry *)jarg2;
27054   if (!arg2) {
27055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27056     return ;
27057   }
27058   {
27059     try {
27060       (arg1)->SetGeometry(*arg2);
27061     } catch (std::out_of_range& e) {
27062       {
27063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27064       };
27065     } catch (std::exception& e) {
27066       {
27067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27068       };
27069     } catch (Dali::DaliException e) {
27070       {
27071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27072       };
27073     } catch (...) {
27074       {
27075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27076       };
27077     }
27078   }
27079
27080 }
27081
27082
27083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27084   void * jresult ;
27085   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27086   Dali::Geometry result;
27087
27088   arg1 = (Dali::Renderer *)jarg1;
27089   {
27090     try {
27091       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27092     } catch (std::out_of_range& e) {
27093       {
27094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (std::exception& e) {
27097       {
27098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27099       };
27100     } catch (Dali::DaliException e) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27103       };
27104     } catch (...) {
27105       {
27106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27107       };
27108     }
27109   }
27110
27111   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27112   return jresult;
27113 }
27114
27115
27116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27117   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27118   int arg2 ;
27119   int arg3 ;
27120
27121   arg1 = (Dali::Renderer *)jarg1;
27122   arg2 = (int)jarg2;
27123   arg3 = (int)jarg3;
27124   {
27125     try {
27126       (arg1)->SetIndexRange(arg2,arg3);
27127     } catch (std::out_of_range& e) {
27128       {
27129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27130       };
27131     } catch (std::exception& e) {
27132       {
27133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27134       };
27135     } catch (Dali::DaliException e) {
27136       {
27137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27138       };
27139     } catch (...) {
27140       {
27141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27142       };
27143     }
27144   }
27145
27146 }
27147
27148
27149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27150   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27151   Dali::TextureSet *arg2 = 0 ;
27152
27153   arg1 = (Dali::Renderer *)jarg1;
27154   arg2 = (Dali::TextureSet *)jarg2;
27155   if (!arg2) {
27156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27157     return ;
27158   }
27159   {
27160     try {
27161       (arg1)->SetTextures(*arg2);
27162     } catch (std::out_of_range& e) {
27163       {
27164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27165       };
27166     } catch (std::exception& e) {
27167       {
27168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27169       };
27170     } catch (Dali::DaliException e) {
27171       {
27172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27173       };
27174     } catch (...) {
27175       {
27176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27177       };
27178     }
27179   }
27180
27181 }
27182
27183
27184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27185   void * jresult ;
27186   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27187   Dali::TextureSet result;
27188
27189   arg1 = (Dali::Renderer *)jarg1;
27190   {
27191     try {
27192       result = ((Dali::Renderer const *)arg1)->GetTextures();
27193     } catch (std::out_of_range& e) {
27194       {
27195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27196       };
27197     } catch (std::exception& e) {
27198       {
27199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27200       };
27201     } catch (Dali::DaliException e) {
27202       {
27203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27204       };
27205     } catch (...) {
27206       {
27207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27208       };
27209     }
27210   }
27211
27212   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27213   return jresult;
27214 }
27215
27216
27217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27218   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27219   Dali::Shader *arg2 = 0 ;
27220
27221   arg1 = (Dali::Renderer *)jarg1;
27222   arg2 = (Dali::Shader *)jarg2;
27223   if (!arg2) {
27224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27225     return ;
27226   }
27227   {
27228     try {
27229       (arg1)->SetShader(*arg2);
27230     } catch (std::out_of_range& e) {
27231       {
27232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27233       };
27234     } catch (std::exception& e) {
27235       {
27236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27237       };
27238     } catch (Dali::DaliException e) {
27239       {
27240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27241       };
27242     } catch (...) {
27243       {
27244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27245       };
27246     }
27247   }
27248
27249 }
27250
27251
27252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27253   void * jresult ;
27254   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27255   Dali::Shader result;
27256
27257   arg1 = (Dali::Renderer *)jarg1;
27258   {
27259     try {
27260       result = ((Dali::Renderer const *)arg1)->GetShader();
27261     } catch (std::out_of_range& e) {
27262       {
27263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27264       };
27265     } catch (std::exception& e) {
27266       {
27267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27268       };
27269     } catch (Dali::DaliException e) {
27270       {
27271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27272       };
27273     } catch (...) {
27274       {
27275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27276       };
27277     }
27278   }
27279
27280   jresult = new Dali::Shader((const Dali::Shader &)result);
27281   return jresult;
27282 }
27283
27284
27285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27286   void * jresult ;
27287   Dali::FrameBuffer::Attachment *result = 0 ;
27288
27289   {
27290     try {
27291       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27292     } catch (std::out_of_range& e) {
27293       {
27294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27295       };
27296     } catch (std::exception& e) {
27297       {
27298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27299       };
27300     } catch (Dali::DaliException e) {
27301       {
27302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27303       };
27304     } catch (...) {
27305       {
27306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27307       };
27308     }
27309   }
27310
27311   jresult = (void *)result;
27312   return jresult;
27313 }
27314
27315
27316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27317   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27318
27319   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27320   {
27321     try {
27322       delete arg1;
27323     } catch (std::out_of_range& e) {
27324       {
27325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27326       };
27327     } catch (std::exception& e) {
27328       {
27329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27330       };
27331     } catch (Dali::DaliException e) {
27332       {
27333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27334       };
27335     } catch (...) {
27336       {
27337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27338       };
27339     }
27340   }
27341
27342 }
27343
27344
27345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27346   void * jresult ;
27347   unsigned int arg1 ;
27348   unsigned int arg2 ;
27349   unsigned int arg3 ;
27350   Dali::FrameBuffer result;
27351
27352   arg1 = (unsigned int)jarg1;
27353   arg2 = (unsigned int)jarg2;
27354   arg3 = (unsigned int)jarg3;
27355   {
27356     try {
27357       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27358     } catch (std::out_of_range& e) {
27359       {
27360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27361       };
27362     } catch (std::exception& e) {
27363       {
27364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27365       };
27366     } catch (Dali::DaliException e) {
27367       {
27368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27369       };
27370     } catch (...) {
27371       {
27372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27373       };
27374     }
27375   }
27376
27377   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27378   return jresult;
27379 }
27380
27381
27382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27383   void * jresult ;
27384   Dali::FrameBuffer *result = 0 ;
27385
27386   {
27387     try {
27388       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27389     } catch (std::out_of_range& e) {
27390       {
27391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27392       };
27393     } catch (std::exception& e) {
27394       {
27395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27396       };
27397     } catch (Dali::DaliException e) {
27398       {
27399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27400       };
27401     } catch (...) {
27402       {
27403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27404       };
27405     }
27406   }
27407
27408   jresult = (void *)result;
27409   return jresult;
27410 }
27411
27412
27413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27414   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27415
27416   arg1 = (Dali::FrameBuffer *)jarg1;
27417   {
27418     try {
27419       delete arg1;
27420     } catch (std::out_of_range& e) {
27421       {
27422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27423       };
27424     } catch (std::exception& e) {
27425       {
27426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27427       };
27428     } catch (Dali::DaliException e) {
27429       {
27430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27431       };
27432     } catch (...) {
27433       {
27434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27435       };
27436     }
27437   }
27438
27439 }
27440
27441
27442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27443   void * jresult ;
27444   Dali::FrameBuffer *arg1 = 0 ;
27445   Dali::FrameBuffer *result = 0 ;
27446
27447   arg1 = (Dali::FrameBuffer *)jarg1;
27448   if (!arg1) {
27449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27450     return 0;
27451   }
27452   {
27453     try {
27454       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27455     } catch (std::out_of_range& e) {
27456       {
27457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27458       };
27459     } catch (std::exception& e) {
27460       {
27461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27462       };
27463     } catch (Dali::DaliException e) {
27464       {
27465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27466       };
27467     } catch (...) {
27468       {
27469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27470       };
27471     }
27472   }
27473
27474   jresult = (void *)result;
27475   return jresult;
27476 }
27477
27478
27479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27480   void * jresult ;
27481   Dali::BaseHandle arg1 ;
27482   Dali::BaseHandle *argp1 ;
27483   Dali::FrameBuffer result;
27484
27485   argp1 = (Dali::BaseHandle *)jarg1;
27486   if (!argp1) {
27487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27488     return 0;
27489   }
27490   arg1 = *argp1;
27491   {
27492     try {
27493       result = Dali::FrameBuffer::DownCast(arg1);
27494     } catch (std::out_of_range& e) {
27495       {
27496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27497       };
27498     } catch (std::exception& e) {
27499       {
27500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27501       };
27502     } catch (Dali::DaliException e) {
27503       {
27504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27505       };
27506     } catch (...) {
27507       {
27508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27509       };
27510     }
27511   }
27512
27513   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27514   return jresult;
27515 }
27516
27517
27518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27519   void * jresult ;
27520   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27521   Dali::FrameBuffer *arg2 = 0 ;
27522   Dali::FrameBuffer *result = 0 ;
27523
27524   arg1 = (Dali::FrameBuffer *)jarg1;
27525   arg2 = (Dali::FrameBuffer *)jarg2;
27526   if (!arg2) {
27527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27528     return 0;
27529   }
27530   {
27531     try {
27532       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27533     } catch (std::out_of_range& e) {
27534       {
27535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27536       };
27537     } catch (std::exception& e) {
27538       {
27539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27540       };
27541     } catch (Dali::DaliException e) {
27542       {
27543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27544       };
27545     } catch (...) {
27546       {
27547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27548       };
27549     }
27550   }
27551
27552   jresult = (void *)result;
27553   return jresult;
27554 }
27555
27556
27557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27558   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27559   Dali::Texture *arg2 = 0 ;
27560
27561   arg1 = (Dali::FrameBuffer *)jarg1;
27562   arg2 = (Dali::Texture *)jarg2;
27563   if (!arg2) {
27564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27565     return ;
27566   }
27567   {
27568     try {
27569       (arg1)->AttachColorTexture(*arg2);
27570     } catch (std::out_of_range& e) {
27571       {
27572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27573       };
27574     } catch (std::exception& e) {
27575       {
27576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27577       };
27578     } catch (Dali::DaliException e) {
27579       {
27580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27581       };
27582     } catch (...) {
27583       {
27584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27585       };
27586     }
27587   }
27588
27589 }
27590
27591
27592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27593   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27594   Dali::Texture *arg2 = 0 ;
27595   unsigned int arg3 ;
27596   unsigned int arg4 ;
27597
27598   arg1 = (Dali::FrameBuffer *)jarg1;
27599   arg2 = (Dali::Texture *)jarg2;
27600   if (!arg2) {
27601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27602     return ;
27603   }
27604   arg3 = (unsigned int)jarg3;
27605   arg4 = (unsigned int)jarg4;
27606   {
27607     try {
27608       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27609     } catch (std::out_of_range& e) {
27610       {
27611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27612       };
27613     } catch (std::exception& e) {
27614       {
27615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27616       };
27617     } catch (Dali::DaliException e) {
27618       {
27619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27620       };
27621     } catch (...) {
27622       {
27623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27624       };
27625     }
27626   }
27627
27628 }
27629
27630
27631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27632   void * jresult ;
27633   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27634   Dali::Texture result;
27635
27636   arg1 = (Dali::FrameBuffer *)jarg1;
27637   {
27638     try {
27639       result = (arg1)->GetColorTexture();
27640     } catch (std::out_of_range& e) {
27641       {
27642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27643       };
27644     } catch (std::exception& e) {
27645       {
27646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27647       };
27648     } catch (Dali::DaliException e) {
27649       {
27650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27651       };
27652     } catch (...) {
27653       {
27654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27655       };
27656     }
27657   }
27658
27659   jresult = new Dali::Texture((const Dali::Texture &)result);
27660   return jresult;
27661 }
27662
27663
27664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27665   void * jresult ;
27666   Dali::RenderTaskList *result = 0 ;
27667
27668   {
27669     try {
27670       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27671     } catch (std::out_of_range& e) {
27672       {
27673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27674       };
27675     } catch (std::exception& e) {
27676       {
27677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27678       };
27679     } catch (Dali::DaliException e) {
27680       {
27681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27682       };
27683     } catch (...) {
27684       {
27685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27686       };
27687     }
27688   }
27689
27690   jresult = (void *)result;
27691   return jresult;
27692 }
27693
27694
27695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27696   void * jresult ;
27697   Dali::BaseHandle arg1 ;
27698   Dali::BaseHandle *argp1 ;
27699   Dali::RenderTaskList result;
27700
27701   argp1 = (Dali::BaseHandle *)jarg1;
27702   if (!argp1) {
27703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27704     return 0;
27705   }
27706   arg1 = *argp1;
27707   {
27708     try {
27709       result = Dali::RenderTaskList::DownCast(arg1);
27710     } catch (std::out_of_range& e) {
27711       {
27712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27713       };
27714     } catch (std::exception& e) {
27715       {
27716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27717       };
27718     } catch (Dali::DaliException e) {
27719       {
27720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27721       };
27722     } catch (...) {
27723       {
27724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27725       };
27726     }
27727   }
27728
27729   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27730   return jresult;
27731 }
27732
27733
27734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27735   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27736
27737   arg1 = (Dali::RenderTaskList *)jarg1;
27738   {
27739     try {
27740       delete arg1;
27741     } catch (std::out_of_range& e) {
27742       {
27743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27744       };
27745     } catch (std::exception& e) {
27746       {
27747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27748       };
27749     } catch (Dali::DaliException e) {
27750       {
27751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27752       };
27753     } catch (...) {
27754       {
27755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27756       };
27757     }
27758   }
27759
27760 }
27761
27762
27763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27764   void * jresult ;
27765   Dali::RenderTaskList *arg1 = 0 ;
27766   Dali::RenderTaskList *result = 0 ;
27767
27768   arg1 = (Dali::RenderTaskList *)jarg1;
27769   if (!arg1) {
27770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27771     return 0;
27772   }
27773   {
27774     try {
27775       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27776     } catch (std::out_of_range& e) {
27777       {
27778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27779       };
27780     } catch (std::exception& e) {
27781       {
27782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27783       };
27784     } catch (Dali::DaliException e) {
27785       {
27786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27787       };
27788     } catch (...) {
27789       {
27790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27791       };
27792     }
27793   }
27794
27795   jresult = (void *)result;
27796   return jresult;
27797 }
27798
27799
27800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27801   void * jresult ;
27802   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27803   Dali::RenderTaskList *arg2 = 0 ;
27804   Dali::RenderTaskList *result = 0 ;
27805
27806   arg1 = (Dali::RenderTaskList *)jarg1;
27807   arg2 = (Dali::RenderTaskList *)jarg2;
27808   if (!arg2) {
27809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27810     return 0;
27811   }
27812   {
27813     try {
27814       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27815     } catch (std::out_of_range& e) {
27816       {
27817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27818       };
27819     } catch (std::exception& e) {
27820       {
27821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27822       };
27823     } catch (Dali::DaliException e) {
27824       {
27825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27826       };
27827     } catch (...) {
27828       {
27829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27830       };
27831     }
27832   }
27833
27834   jresult = (void *)result;
27835   return jresult;
27836 }
27837
27838
27839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27840   void * jresult ;
27841   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27842   Dali::RenderTask result;
27843
27844   arg1 = (Dali::RenderTaskList *)jarg1;
27845   {
27846     try {
27847       result = (arg1)->CreateTask();
27848     } catch (std::out_of_range& e) {
27849       {
27850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27851       };
27852     } catch (std::exception& e) {
27853       {
27854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27855       };
27856     } catch (Dali::DaliException e) {
27857       {
27858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27859       };
27860     } catch (...) {
27861       {
27862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27863       };
27864     }
27865   }
27866
27867   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27868   return jresult;
27869 }
27870
27871
27872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27873   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27874   Dali::RenderTask arg2 ;
27875   Dali::RenderTask *argp2 ;
27876
27877   arg1 = (Dali::RenderTaskList *)jarg1;
27878   argp2 = (Dali::RenderTask *)jarg2;
27879   if (!argp2) {
27880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27881     return ;
27882   }
27883   arg2 = *argp2;
27884   {
27885     try {
27886       (arg1)->RemoveTask(arg2);
27887     } catch (std::out_of_range& e) {
27888       {
27889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27890       };
27891     } catch (std::exception& e) {
27892       {
27893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27894       };
27895     } catch (Dali::DaliException e) {
27896       {
27897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27898       };
27899     } catch (...) {
27900       {
27901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27902       };
27903     }
27904   }
27905
27906 }
27907
27908
27909 //// ===============================================end part 1 =================
27910
27911 //// ========================= part 2 ===============================
27912
27913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27914   unsigned int jresult ;
27915   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27916   unsigned int result;
27917
27918   arg1 = (Dali::RenderTaskList *)jarg1;
27919   {
27920     try {
27921       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27922     } catch (std::out_of_range& e) {
27923       {
27924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27925       };
27926     } catch (std::exception& e) {
27927       {
27928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27929       };
27930     } catch (Dali::DaliException e) {
27931       {
27932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27933       };
27934     } catch (...) {
27935       {
27936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27937       };
27938     }
27939   }
27940
27941   jresult = result;
27942   return jresult;
27943 }
27944
27945
27946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27947   void * jresult ;
27948   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27949   unsigned int arg2 ;
27950   Dali::RenderTask result;
27951
27952   arg1 = (Dali::RenderTaskList *)jarg1;
27953   arg2 = (unsigned int)jarg2;
27954   {
27955     try {
27956       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27957     } catch (std::out_of_range& e) {
27958       {
27959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27960       };
27961     } catch (std::exception& e) {
27962       {
27963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27964       };
27965     } catch (Dali::DaliException e) {
27966       {
27967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27968       };
27969     } catch (...) {
27970       {
27971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27972       };
27973     }
27974   }
27975
27976   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27977   return jresult;
27978 }
27979
27980
27981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27982   int jresult ;
27983   int result;
27984
27985   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27986   jresult = (int)result;
27987   return jresult;
27988 }
27989
27990
27991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27992   int jresult ;
27993   int result;
27994
27995   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27996   jresult = (int)result;
27997   return jresult;
27998 }
27999
28000
28001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28002   int jresult ;
28003   int result;
28004
28005   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28006   jresult = (int)result;
28007   return jresult;
28008 }
28009
28010
28011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28012   int jresult ;
28013   int result;
28014
28015   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28016   jresult = (int)result;
28017   return jresult;
28018 }
28019
28020
28021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28022   void * jresult ;
28023   Dali::RenderTask::Property *result = 0 ;
28024
28025   {
28026     try {
28027       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28028     } catch (std::out_of_range& e) {
28029       {
28030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28031       };
28032     } catch (std::exception& e) {
28033       {
28034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28035       };
28036     } catch (Dali::DaliException e) {
28037       {
28038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28039       };
28040     } catch (...) {
28041       {
28042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28043       };
28044     }
28045   }
28046
28047   jresult = (void *)result;
28048   return jresult;
28049 }
28050
28051
28052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28053   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28054
28055   arg1 = (Dali::RenderTask::Property *)jarg1;
28056   {
28057     try {
28058       delete arg1;
28059     } catch (std::out_of_range& e) {
28060       {
28061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28062       };
28063     } catch (std::exception& e) {
28064       {
28065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28066       };
28067     } catch (Dali::DaliException e) {
28068       {
28069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28070       };
28071     } catch (...) {
28072       {
28073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28074       };
28075     }
28076   }
28077
28078 }
28079
28080
28081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28082   void * jresult ;
28083   bool (*result)(Dali::Vector2 &) = 0 ;
28084
28085   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28086   jresult = (void *)result;
28087   return jresult;
28088 }
28089
28090
28091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28092   void * jresult ;
28093   bool (*result)(Dali::Vector2 &) = 0 ;
28094
28095   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28096   jresult = (void *)result;
28097   return jresult;
28098 }
28099
28100
28101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28102   unsigned int jresult ;
28103   bool result;
28104
28105   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28106   jresult = result;
28107   return jresult;
28108 }
28109
28110
28111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28112   unsigned int jresult ;
28113   bool result;
28114
28115   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28116   jresult = result;
28117   return jresult;
28118 }
28119
28120
28121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28122   void * jresult ;
28123   Dali::Vector4 *result = 0 ;
28124
28125   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28126   jresult = (void *)result;
28127   return jresult;
28128 }
28129
28130
28131 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28132   unsigned int jresult ;
28133   bool result;
28134
28135   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28136   jresult = result;
28137   return jresult;
28138 }
28139
28140
28141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28142   unsigned int jresult ;
28143   bool result;
28144
28145   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28146   jresult = result;
28147   return jresult;
28148 }
28149
28150
28151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28152   unsigned int jresult ;
28153   unsigned int result;
28154
28155   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28156   jresult = result;
28157   return jresult;
28158 }
28159
28160
28161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28162   void * jresult ;
28163   Dali::RenderTask *result = 0 ;
28164
28165   {
28166     try {
28167       result = (Dali::RenderTask *)new Dali::RenderTask();
28168     } catch (std::out_of_range& e) {
28169       {
28170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28171       };
28172     } catch (std::exception& e) {
28173       {
28174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28175       };
28176     } catch (Dali::DaliException e) {
28177       {
28178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28179       };
28180     } catch (...) {
28181       {
28182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28183       };
28184     }
28185   }
28186
28187   jresult = (void *)result;
28188   return jresult;
28189 }
28190
28191
28192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28193   void * jresult ;
28194   Dali::BaseHandle arg1 ;
28195   Dali::BaseHandle *argp1 ;
28196   Dali::RenderTask result;
28197
28198   argp1 = (Dali::BaseHandle *)jarg1;
28199   if (!argp1) {
28200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28201     return 0;
28202   }
28203   arg1 = *argp1;
28204   {
28205     try {
28206       result = Dali::RenderTask::DownCast(arg1);
28207     } catch (std::out_of_range& e) {
28208       {
28209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28210       };
28211     } catch (std::exception& e) {
28212       {
28213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28214       };
28215     } catch (Dali::DaliException e) {
28216       {
28217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28218       };
28219     } catch (...) {
28220       {
28221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28222       };
28223     }
28224   }
28225
28226   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28227   return jresult;
28228 }
28229
28230
28231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28232   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28233
28234   arg1 = (Dali::RenderTask *)jarg1;
28235   {
28236     try {
28237       delete arg1;
28238     } catch (std::out_of_range& e) {
28239       {
28240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28241       };
28242     } catch (std::exception& e) {
28243       {
28244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28245       };
28246     } catch (Dali::DaliException e) {
28247       {
28248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28249       };
28250     } catch (...) {
28251       {
28252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28253       };
28254     }
28255   }
28256
28257 }
28258
28259
28260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28261   void * jresult ;
28262   Dali::RenderTask *arg1 = 0 ;
28263   Dali::RenderTask *result = 0 ;
28264
28265   arg1 = (Dali::RenderTask *)jarg1;
28266   if (!arg1) {
28267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28268     return 0;
28269   }
28270   {
28271     try {
28272       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28273     } catch (std::out_of_range& e) {
28274       {
28275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28276       };
28277     } catch (std::exception& e) {
28278       {
28279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28280       };
28281     } catch (Dali::DaliException e) {
28282       {
28283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28284       };
28285     } catch (...) {
28286       {
28287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28288       };
28289     }
28290   }
28291
28292   jresult = (void *)result;
28293   return jresult;
28294 }
28295
28296
28297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28298   void * jresult ;
28299   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28300   Dali::RenderTask *arg2 = 0 ;
28301   Dali::RenderTask *result = 0 ;
28302
28303   arg1 = (Dali::RenderTask *)jarg1;
28304   arg2 = (Dali::RenderTask *)jarg2;
28305   if (!arg2) {
28306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28307     return 0;
28308   }
28309   {
28310     try {
28311       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28312     } catch (std::out_of_range& e) {
28313       {
28314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28315       };
28316     } catch (std::exception& e) {
28317       {
28318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28319       };
28320     } catch (Dali::DaliException e) {
28321       {
28322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28323       };
28324     } catch (...) {
28325       {
28326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28327       };
28328     }
28329   }
28330
28331   jresult = (void *)result;
28332   return jresult;
28333 }
28334
28335
28336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28337   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28338   Dali::Actor arg2 ;
28339   Dali::Actor *argp2 ;
28340
28341   arg1 = (Dali::RenderTask *)jarg1;
28342   argp2 = (Dali::Actor *)jarg2;
28343   if (!argp2) {
28344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28345     return ;
28346   }
28347   arg2 = *argp2;
28348   {
28349     try {
28350       (arg1)->SetSourceActor(arg2);
28351     } catch (std::out_of_range& e) {
28352       {
28353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28354       };
28355     } catch (std::exception& e) {
28356       {
28357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28358       };
28359     } catch (Dali::DaliException e) {
28360       {
28361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28362       };
28363     } catch (...) {
28364       {
28365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28366       };
28367     }
28368   }
28369
28370 }
28371
28372
28373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28374   void * jresult ;
28375   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28376   Dali::Actor result;
28377
28378   arg1 = (Dali::RenderTask *)jarg1;
28379   {
28380     try {
28381       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28382     } catch (std::out_of_range& e) {
28383       {
28384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28385       };
28386     } catch (std::exception& e) {
28387       {
28388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28389       };
28390     } catch (Dali::DaliException e) {
28391       {
28392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28393       };
28394     } catch (...) {
28395       {
28396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28397       };
28398     }
28399   }
28400
28401   jresult = new Dali::Actor((const Dali::Actor &)result);
28402   return jresult;
28403 }
28404
28405
28406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28407   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28408   bool arg2 ;
28409
28410   arg1 = (Dali::RenderTask *)jarg1;
28411   arg2 = jarg2 ? true : false;
28412   {
28413     try {
28414       (arg1)->SetExclusive(arg2);
28415     } catch (std::out_of_range& e) {
28416       {
28417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28418       };
28419     } catch (std::exception& e) {
28420       {
28421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28422       };
28423     } catch (Dali::DaliException e) {
28424       {
28425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28426       };
28427     } catch (...) {
28428       {
28429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28430       };
28431     }
28432   }
28433
28434 }
28435
28436
28437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28438   unsigned int jresult ;
28439   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28440   bool result;
28441
28442   arg1 = (Dali::RenderTask *)jarg1;
28443   {
28444     try {
28445       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28446     } catch (std::out_of_range& e) {
28447       {
28448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28449       };
28450     } catch (std::exception& e) {
28451       {
28452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28453       };
28454     } catch (Dali::DaliException e) {
28455       {
28456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28457       };
28458     } catch (...) {
28459       {
28460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28461       };
28462     }
28463   }
28464
28465   jresult = result;
28466   return jresult;
28467 }
28468
28469
28470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28471   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28472   bool arg2 ;
28473
28474   arg1 = (Dali::RenderTask *)jarg1;
28475   arg2 = jarg2 ? true : false;
28476   {
28477     try {
28478       (arg1)->SetInputEnabled(arg2);
28479     } catch (std::out_of_range& e) {
28480       {
28481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28482       };
28483     } catch (std::exception& e) {
28484       {
28485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28486       };
28487     } catch (Dali::DaliException e) {
28488       {
28489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28490       };
28491     } catch (...) {
28492       {
28493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28494       };
28495     }
28496   }
28497
28498 }
28499
28500
28501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28502   unsigned int jresult ;
28503   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28504   bool result;
28505
28506   arg1 = (Dali::RenderTask *)jarg1;
28507   {
28508     try {
28509       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28510     } catch (std::out_of_range& e) {
28511       {
28512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28513       };
28514     } catch (std::exception& e) {
28515       {
28516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28517       };
28518     } catch (Dali::DaliException e) {
28519       {
28520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28521       };
28522     } catch (...) {
28523       {
28524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28525       };
28526     }
28527   }
28528
28529   jresult = result;
28530   return jresult;
28531 }
28532
28533
28534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28535   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28536   Dali::CameraActor arg2 ;
28537   Dali::CameraActor *argp2 ;
28538
28539   arg1 = (Dali::RenderTask *)jarg1;
28540   argp2 = (Dali::CameraActor *)jarg2;
28541   if (!argp2) {
28542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28543     return ;
28544   }
28545   arg2 = *argp2;
28546   {
28547     try {
28548       (arg1)->SetCameraActor(arg2);
28549     } catch (std::out_of_range& e) {
28550       {
28551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28552       };
28553     } catch (std::exception& e) {
28554       {
28555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28556       };
28557     } catch (Dali::DaliException e) {
28558       {
28559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28560       };
28561     } catch (...) {
28562       {
28563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28564       };
28565     }
28566   }
28567
28568 }
28569
28570
28571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28572   void * jresult ;
28573   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28574   Dali::CameraActor result;
28575
28576   arg1 = (Dali::RenderTask *)jarg1;
28577   {
28578     try {
28579       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28580     } catch (std::out_of_range& e) {
28581       {
28582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28583       };
28584     } catch (std::exception& e) {
28585       {
28586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28587       };
28588     } catch (Dali::DaliException e) {
28589       {
28590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28591       };
28592     } catch (...) {
28593       {
28594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28595       };
28596     }
28597   }
28598
28599   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28600   return jresult;
28601 }
28602
28603
28604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28605   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28606   Dali::FrameBufferImage arg2 ;
28607   Dali::FrameBufferImage *argp2 ;
28608
28609   arg1 = (Dali::RenderTask *)jarg1;
28610   argp2 = (Dali::FrameBufferImage *)jarg2;
28611   if (!argp2) {
28612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28613     return ;
28614   }
28615   arg2 = *argp2;
28616   {
28617     try {
28618       (arg1)->SetTargetFrameBuffer(arg2);
28619     } catch (std::out_of_range& e) {
28620       {
28621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28622       };
28623     } catch (std::exception& e) {
28624       {
28625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28626       };
28627     } catch (Dali::DaliException e) {
28628       {
28629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28630       };
28631     } catch (...) {
28632       {
28633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28634       };
28635     }
28636   }
28637
28638 }
28639
28640
28641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28642   void * jresult ;
28643   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28644   Dali::FrameBufferImage result;
28645
28646   arg1 = (Dali::RenderTask *)jarg1;
28647   {
28648     try {
28649       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28650     } catch (std::out_of_range& e) {
28651       {
28652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28653       };
28654     } catch (std::exception& e) {
28655       {
28656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28657       };
28658     } catch (Dali::DaliException e) {
28659       {
28660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28661       };
28662     } catch (...) {
28663       {
28664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28665       };
28666     }
28667   }
28668
28669   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28670   return jresult;
28671 }
28672
28673
28674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28675   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28676   Dali::FrameBuffer arg2 ;
28677   Dali::FrameBuffer *argp2 ;
28678
28679   arg1 = (Dali::RenderTask *)jarg1;
28680   argp2 = (Dali::FrameBuffer *)jarg2;
28681   if (!argp2) {
28682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28683     return ;
28684   }
28685   arg2 = *argp2;
28686   {
28687     try {
28688       (arg1)->SetFrameBuffer(arg2);
28689     } catch (std::out_of_range& e) {
28690       {
28691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28692       };
28693     } catch (std::exception& e) {
28694       {
28695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28696       };
28697     } catch (Dali::DaliException e) {
28698       {
28699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28700       };
28701     } catch (...) {
28702       {
28703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28704       };
28705     }
28706   }
28707
28708 }
28709
28710
28711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28712   void * jresult ;
28713   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28714   Dali::FrameBuffer result;
28715
28716   arg1 = (Dali::RenderTask *)jarg1;
28717   {
28718     try {
28719       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28720     } catch (std::out_of_range& e) {
28721       {
28722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28723       };
28724     } catch (std::exception& e) {
28725       {
28726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28727       };
28728     } catch (Dali::DaliException e) {
28729       {
28730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28731       };
28732     } catch (...) {
28733       {
28734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28735       };
28736     }
28737   }
28738
28739   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28740   return jresult;
28741 }
28742
28743
28744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28745   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28746   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28747
28748   arg1 = (Dali::RenderTask *)jarg1;
28749   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28750   {
28751     try {
28752       (arg1)->SetScreenToFrameBufferFunction(arg2);
28753     } catch (std::out_of_range& e) {
28754       {
28755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28756       };
28757     } catch (std::exception& e) {
28758       {
28759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28760       };
28761     } catch (Dali::DaliException e) {
28762       {
28763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28764       };
28765     } catch (...) {
28766       {
28767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28768       };
28769     }
28770   }
28771
28772 }
28773
28774
28775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28776   void * jresult ;
28777   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28778   Dali::RenderTask::ScreenToFrameBufferFunction result;
28779
28780   arg1 = (Dali::RenderTask *)jarg1;
28781   {
28782     try {
28783       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28784     } catch (std::out_of_range& e) {
28785       {
28786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28787       };
28788     } catch (std::exception& e) {
28789       {
28790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28791       };
28792     } catch (Dali::DaliException e) {
28793       {
28794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28795       };
28796     } catch (...) {
28797       {
28798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28799       };
28800     }
28801   }
28802
28803   jresult = (void *)result;
28804   return jresult;
28805 }
28806
28807
28808 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28809   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28810   Dali::Actor arg2 ;
28811   Dali::Actor *argp2 ;
28812
28813   arg1 = (Dali::RenderTask *)jarg1;
28814   argp2 = (Dali::Actor *)jarg2;
28815   if (!argp2) {
28816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28817     return ;
28818   }
28819   arg2 = *argp2;
28820   {
28821     try {
28822       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28823     } catch (std::out_of_range& e) {
28824       {
28825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28826       };
28827     } catch (std::exception& e) {
28828       {
28829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28830       };
28831     } catch (Dali::DaliException e) {
28832       {
28833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28834       };
28835     } catch (...) {
28836       {
28837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28838       };
28839     }
28840   }
28841
28842 }
28843
28844
28845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28846   void * jresult ;
28847   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28848   Dali::Actor result;
28849
28850   arg1 = (Dali::RenderTask *)jarg1;
28851   {
28852     try {
28853       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28854     } catch (std::out_of_range& e) {
28855       {
28856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28857       };
28858     } catch (std::exception& e) {
28859       {
28860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28861       };
28862     } catch (Dali::DaliException e) {
28863       {
28864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28865       };
28866     } catch (...) {
28867       {
28868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28869       };
28870     }
28871   }
28872
28873   jresult = new Dali::Actor((const Dali::Actor &)result);
28874   return jresult;
28875 }
28876
28877
28878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28879   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28880   Dali::Vector2 arg2 ;
28881   Dali::Vector2 *argp2 ;
28882
28883   arg1 = (Dali::RenderTask *)jarg1;
28884   argp2 = (Dali::Vector2 *)jarg2;
28885   if (!argp2) {
28886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28887     return ;
28888   }
28889   arg2 = *argp2;
28890   {
28891     try {
28892       (arg1)->SetViewportPosition(arg2);
28893     } catch (std::out_of_range& e) {
28894       {
28895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28896       };
28897     } catch (std::exception& e) {
28898       {
28899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28900       };
28901     } catch (Dali::DaliException e) {
28902       {
28903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28904       };
28905     } catch (...) {
28906       {
28907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28908       };
28909     }
28910   }
28911
28912 }
28913
28914
28915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28916   void * jresult ;
28917   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28918   Dali::Vector2 result;
28919
28920   arg1 = (Dali::RenderTask *)jarg1;
28921   {
28922     try {
28923       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28924     } catch (std::out_of_range& e) {
28925       {
28926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28927       };
28928     } catch (std::exception& e) {
28929       {
28930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28931       };
28932     } catch (Dali::DaliException e) {
28933       {
28934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28935       };
28936     } catch (...) {
28937       {
28938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28939       };
28940     }
28941   }
28942
28943   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28944   return jresult;
28945 }
28946
28947
28948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28949   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28950   Dali::Vector2 arg2 ;
28951   Dali::Vector2 *argp2 ;
28952
28953   arg1 = (Dali::RenderTask *)jarg1;
28954   argp2 = (Dali::Vector2 *)jarg2;
28955   if (!argp2) {
28956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28957     return ;
28958   }
28959   arg2 = *argp2;
28960   {
28961     try {
28962       (arg1)->SetViewportSize(arg2);
28963     } catch (std::out_of_range& e) {
28964       {
28965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28966       };
28967     } catch (std::exception& e) {
28968       {
28969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28970       };
28971     } catch (Dali::DaliException e) {
28972       {
28973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28974       };
28975     } catch (...) {
28976       {
28977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28978       };
28979     }
28980   }
28981
28982 }
28983
28984
28985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28986   void * jresult ;
28987   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28988   Dali::Vector2 result;
28989
28990   arg1 = (Dali::RenderTask *)jarg1;
28991   {
28992     try {
28993       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28994     } catch (std::out_of_range& e) {
28995       {
28996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28997       };
28998     } catch (std::exception& e) {
28999       {
29000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29001       };
29002     } catch (Dali::DaliException e) {
29003       {
29004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29005       };
29006     } catch (...) {
29007       {
29008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29009       };
29010     }
29011   }
29012
29013   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29014   return jresult;
29015 }
29016
29017
29018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29019   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29020   Dali::Viewport arg2 ;
29021   Dali::Viewport *argp2 ;
29022
29023   arg1 = (Dali::RenderTask *)jarg1;
29024   argp2 = (Dali::Viewport *)jarg2;
29025   if (!argp2) {
29026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29027     return ;
29028   }
29029   arg2 = *argp2;
29030   {
29031     try {
29032       (arg1)->SetViewport(arg2);
29033     } catch (std::out_of_range& e) {
29034       {
29035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29036       };
29037     } catch (std::exception& e) {
29038       {
29039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29040       };
29041     } catch (Dali::DaliException e) {
29042       {
29043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29044       };
29045     } catch (...) {
29046       {
29047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29048       };
29049     }
29050   }
29051
29052 }
29053
29054
29055 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29056   void * jresult ;
29057   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29058   Dali::Viewport result;
29059
29060   arg1 = (Dali::RenderTask *)jarg1;
29061   {
29062     try {
29063       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29064     } catch (std::out_of_range& e) {
29065       {
29066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29067       };
29068     } catch (std::exception& e) {
29069       {
29070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29071       };
29072     } catch (Dali::DaliException e) {
29073       {
29074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29075       };
29076     } catch (...) {
29077       {
29078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29079       };
29080     }
29081   }
29082
29083   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29084   return jresult;
29085 }
29086
29087
29088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29089   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29090   Dali::Vector4 *arg2 = 0 ;
29091
29092   arg1 = (Dali::RenderTask *)jarg1;
29093   arg2 = (Dali::Vector4 *)jarg2;
29094   if (!arg2) {
29095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29096     return ;
29097   }
29098   {
29099     try {
29100       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29101     } catch (std::out_of_range& e) {
29102       {
29103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29104       };
29105     } catch (std::exception& e) {
29106       {
29107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29108       };
29109     } catch (Dali::DaliException e) {
29110       {
29111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29112       };
29113     } catch (...) {
29114       {
29115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29116       };
29117     }
29118   }
29119
29120 }
29121
29122
29123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29124   void * jresult ;
29125   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29126   Dali::Vector4 result;
29127
29128   arg1 = (Dali::RenderTask *)jarg1;
29129   {
29130     try {
29131       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29132     } catch (std::out_of_range& e) {
29133       {
29134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29135       };
29136     } catch (std::exception& e) {
29137       {
29138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29139       };
29140     } catch (Dali::DaliException e) {
29141       {
29142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29143       };
29144     } catch (...) {
29145       {
29146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29147       };
29148     }
29149   }
29150
29151   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29152   return jresult;
29153 }
29154
29155
29156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29157   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29158   bool arg2 ;
29159
29160   arg1 = (Dali::RenderTask *)jarg1;
29161   arg2 = jarg2 ? true : false;
29162   {
29163     try {
29164       (arg1)->SetClearEnabled(arg2);
29165     } catch (std::out_of_range& e) {
29166       {
29167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29168       };
29169     } catch (std::exception& e) {
29170       {
29171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29172       };
29173     } catch (Dali::DaliException e) {
29174       {
29175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29176       };
29177     } catch (...) {
29178       {
29179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29180       };
29181     }
29182   }
29183
29184 }
29185
29186
29187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29188   unsigned int jresult ;
29189   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29190   bool result;
29191
29192   arg1 = (Dali::RenderTask *)jarg1;
29193   {
29194     try {
29195       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29196     } catch (std::out_of_range& e) {
29197       {
29198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29199       };
29200     } catch (std::exception& e) {
29201       {
29202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29203       };
29204     } catch (Dali::DaliException e) {
29205       {
29206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29207       };
29208     } catch (...) {
29209       {
29210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29211       };
29212     }
29213   }
29214
29215   jresult = result;
29216   return jresult;
29217 }
29218
29219
29220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29221   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29222   bool arg2 ;
29223
29224   arg1 = (Dali::RenderTask *)jarg1;
29225   arg2 = jarg2 ? true : false;
29226   {
29227     try {
29228       (arg1)->SetCullMode(arg2);
29229     } catch (std::out_of_range& e) {
29230       {
29231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29232       };
29233     } catch (std::exception& e) {
29234       {
29235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29236       };
29237     } catch (Dali::DaliException e) {
29238       {
29239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29240       };
29241     } catch (...) {
29242       {
29243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29244       };
29245     }
29246   }
29247
29248 }
29249
29250
29251 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29252   unsigned int jresult ;
29253   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29254   bool result;
29255
29256   arg1 = (Dali::RenderTask *)jarg1;
29257   {
29258     try {
29259       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29260     } catch (std::out_of_range& e) {
29261       {
29262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29263       };
29264     } catch (std::exception& e) {
29265       {
29266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29267       };
29268     } catch (Dali::DaliException e) {
29269       {
29270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29271       };
29272     } catch (...) {
29273       {
29274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29275       };
29276     }
29277   }
29278
29279   jresult = result;
29280   return jresult;
29281 }
29282
29283
29284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29285   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29286   unsigned int arg2 ;
29287
29288   arg1 = (Dali::RenderTask *)jarg1;
29289   arg2 = (unsigned int)jarg2;
29290   {
29291     try {
29292       (arg1)->SetRefreshRate(arg2);
29293     } catch (std::out_of_range& e) {
29294       {
29295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29296       };
29297     } catch (std::exception& e) {
29298       {
29299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29300       };
29301     } catch (Dali::DaliException e) {
29302       {
29303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29304       };
29305     } catch (...) {
29306       {
29307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29308       };
29309     }
29310   }
29311
29312 }
29313
29314
29315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29316   unsigned int jresult ;
29317   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29318   unsigned int result;
29319
29320   arg1 = (Dali::RenderTask *)jarg1;
29321   {
29322     try {
29323       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29324     } catch (std::out_of_range& e) {
29325       {
29326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29327       };
29328     } catch (std::exception& e) {
29329       {
29330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29331       };
29332     } catch (Dali::DaliException e) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29335       };
29336     } catch (...) {
29337       {
29338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29339       };
29340     }
29341   }
29342
29343   jresult = result;
29344   return jresult;
29345 }
29346
29347
29348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29349   unsigned int jresult ;
29350   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29351   Dali::Vector3 *arg2 = 0 ;
29352   float *arg3 = 0 ;
29353   float *arg4 = 0 ;
29354   bool result;
29355
29356   arg1 = (Dali::RenderTask *)jarg1;
29357   arg2 = (Dali::Vector3 *)jarg2;
29358   if (!arg2) {
29359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29360     return 0;
29361   }
29362   arg3 = (float *)jarg3;
29363   arg4 = (float *)jarg4;
29364   {
29365     try {
29366       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29367     } catch (std::out_of_range& e) {
29368       {
29369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29370       };
29371     } catch (std::exception& e) {
29372       {
29373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29374       };
29375     } catch (Dali::DaliException e) {
29376       {
29377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29378       };
29379     } catch (...) {
29380       {
29381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29382       };
29383     }
29384   }
29385
29386   jresult = result;
29387   return jresult;
29388 }
29389
29390
29391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29392   unsigned int jresult ;
29393   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29394   Dali::Actor arg2 ;
29395   float arg3 ;
29396   float arg4 ;
29397   float *arg5 = 0 ;
29398   float *arg6 = 0 ;
29399   Dali::Actor *argp2 ;
29400   bool result;
29401
29402   arg1 = (Dali::RenderTask *)jarg1;
29403   argp2 = (Dali::Actor *)jarg2;
29404   if (!argp2) {
29405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29406     return 0;
29407   }
29408   arg2 = *argp2;
29409   arg3 = (float)jarg3;
29410   arg4 = (float)jarg4;
29411   arg5 = (float *)jarg5;
29412   arg6 = (float *)jarg6;
29413   {
29414     try {
29415       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29416     } catch (std::out_of_range& e) {
29417       {
29418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29419       };
29420     } catch (std::exception& e) {
29421       {
29422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29423       };
29424     } catch (Dali::DaliException e) {
29425       {
29426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29427       };
29428     } catch (...) {
29429       {
29430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29431       };
29432     }
29433   }
29434
29435   jresult = result;
29436   return jresult;
29437 }
29438
29439
29440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29441   void * jresult ;
29442   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29443   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29444
29445   arg1 = (Dali::RenderTask *)jarg1;
29446   {
29447     try {
29448       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29449     } catch (std::out_of_range& e) {
29450       {
29451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29452       };
29453     } catch (std::exception& e) {
29454       {
29455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29456       };
29457     } catch (Dali::DaliException e) {
29458       {
29459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29460       };
29461     } catch (...) {
29462       {
29463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29464       };
29465     }
29466   }
29467
29468   jresult = (void *)result;
29469   return jresult;
29470 }
29471
29472
29473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29474   void * jresult ;
29475   int arg1 ;
29476   Dali::TouchPoint::State arg2 ;
29477   float arg3 ;
29478   float arg4 ;
29479   Dali::TouchPoint *result = 0 ;
29480
29481   arg1 = (int)jarg1;
29482   arg2 = (Dali::TouchPoint::State)jarg2;
29483   arg3 = (float)jarg3;
29484   arg4 = (float)jarg4;
29485   {
29486     try {
29487       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29488     } catch (std::out_of_range& e) {
29489       {
29490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29491       };
29492     } catch (std::exception& e) {
29493       {
29494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29495       };
29496     } catch (Dali::DaliException e) {
29497       {
29498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29499       };
29500     } catch (...) {
29501       {
29502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29503       };
29504     }
29505   }
29506
29507   jresult = (void *)result;
29508   return jresult;
29509 }
29510
29511
29512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29513   void * jresult ;
29514   int arg1 ;
29515   Dali::TouchPoint::State arg2 ;
29516   float arg3 ;
29517   float arg4 ;
29518   float arg5 ;
29519   float arg6 ;
29520   Dali::TouchPoint *result = 0 ;
29521
29522   arg1 = (int)jarg1;
29523   arg2 = (Dali::TouchPoint::State)jarg2;
29524   arg3 = (float)jarg3;
29525   arg4 = (float)jarg4;
29526   arg5 = (float)jarg5;
29527   arg6 = (float)jarg6;
29528   {
29529     try {
29530       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29531     } catch (std::out_of_range& e) {
29532       {
29533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29534       };
29535     } catch (std::exception& e) {
29536       {
29537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29538       };
29539     } catch (Dali::DaliException e) {
29540       {
29541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29542       };
29543     } catch (...) {
29544       {
29545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29546       };
29547     }
29548   }
29549
29550   jresult = (void *)result;
29551   return jresult;
29552 }
29553
29554
29555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29556   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29557
29558   arg1 = (Dali::TouchPoint *)jarg1;
29559   {
29560     try {
29561       delete arg1;
29562     } catch (std::out_of_range& e) {
29563       {
29564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29565       };
29566     } catch (std::exception& e) {
29567       {
29568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29569       };
29570     } catch (Dali::DaliException e) {
29571       {
29572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29573       };
29574     } catch (...) {
29575       {
29576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29577       };
29578     }
29579   }
29580
29581 }
29582
29583
29584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29585   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29586   int arg2 ;
29587
29588   arg1 = (Dali::TouchPoint *)jarg1;
29589   arg2 = (int)jarg2;
29590   if (arg1) (arg1)->deviceId = arg2;
29591 }
29592
29593
29594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29595   int jresult ;
29596   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29597   int result;
29598
29599   arg1 = (Dali::TouchPoint *)jarg1;
29600   result = (int) ((arg1)->deviceId);
29601   jresult = result;
29602   return jresult;
29603 }
29604
29605
29606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29607   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29608   Dali::TouchPoint::State arg2 ;
29609
29610   arg1 = (Dali::TouchPoint *)jarg1;
29611   arg2 = (Dali::TouchPoint::State)jarg2;
29612   if (arg1) (arg1)->state = arg2;
29613 }
29614
29615
29616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29617   int jresult ;
29618   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29619   Dali::TouchPoint::State result;
29620
29621   arg1 = (Dali::TouchPoint *)jarg1;
29622   result = (Dali::TouchPoint::State) ((arg1)->state);
29623   jresult = (int)result;
29624   return jresult;
29625 }
29626
29627
29628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29629   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29630   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29631
29632   arg1 = (Dali::TouchPoint *)jarg1;
29633   arg2 = (Dali::Actor *)jarg2;
29634   if (arg1) (arg1)->hitActor = *arg2;
29635 }
29636
29637
29638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29639   void * jresult ;
29640   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29641   Dali::Actor *result = 0 ;
29642
29643   arg1 = (Dali::TouchPoint *)jarg1;
29644   result = (Dali::Actor *)& ((arg1)->hitActor);
29645   jresult = (void *)result;
29646   return jresult;
29647 }
29648
29649
29650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29651   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29652   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29653
29654   arg1 = (Dali::TouchPoint *)jarg1;
29655   arg2 = (Dali::Vector2 *)jarg2;
29656   if (arg1) (arg1)->local = *arg2;
29657 }
29658
29659
29660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29661   void * jresult ;
29662   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29663   Dali::Vector2 *result = 0 ;
29664
29665   arg1 = (Dali::TouchPoint *)jarg1;
29666   result = (Dali::Vector2 *)& ((arg1)->local);
29667   jresult = (void *)result;
29668   return jresult;
29669 }
29670
29671
29672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29673   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29674   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29675
29676   arg1 = (Dali::TouchPoint *)jarg1;
29677   arg2 = (Dali::Vector2 *)jarg2;
29678   if (arg1) (arg1)->screen = *arg2;
29679 }
29680
29681
29682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29683   void * jresult ;
29684   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29685   Dali::Vector2 *result = 0 ;
29686
29687   arg1 = (Dali::TouchPoint *)jarg1;
29688   result = (Dali::Vector2 *)& ((arg1)->screen);
29689   jresult = (void *)result;
29690   return jresult;
29691 }
29692
29693
29694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29695   void * jresult ;
29696   Dali::TouchData *result = 0 ;
29697
29698   {
29699     try {
29700       result = (Dali::TouchData *)new Dali::TouchData();
29701     } catch (std::out_of_range& e) {
29702       {
29703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29704       };
29705     } catch (std::exception& e) {
29706       {
29707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29708       };
29709     } catch (Dali::DaliException e) {
29710       {
29711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29712       };
29713     } catch (...) {
29714       {
29715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29716       };
29717     }
29718   }
29719
29720   jresult = (void *)result;
29721   return jresult;
29722 }
29723
29724
29725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29726   void * jresult ;
29727   Dali::TouchData *arg1 = 0 ;
29728   Dali::TouchData *result = 0 ;
29729
29730   arg1 = (Dali::TouchData *)jarg1;
29731   if (!arg1) {
29732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29733     return 0;
29734   }
29735   {
29736     try {
29737       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29738     } catch (std::out_of_range& e) {
29739       {
29740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29741       };
29742     } catch (std::exception& e) {
29743       {
29744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29745       };
29746     } catch (Dali::DaliException e) {
29747       {
29748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29749       };
29750     } catch (...) {
29751       {
29752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29753       };
29754     }
29755   }
29756
29757   jresult = (void *)result;
29758   return jresult;
29759 }
29760
29761
29762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29763   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29764
29765   arg1 = (Dali::TouchData *)jarg1;
29766   {
29767     try {
29768       delete arg1;
29769     } catch (std::out_of_range& e) {
29770       {
29771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29772       };
29773     } catch (std::exception& e) {
29774       {
29775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29776       };
29777     } catch (Dali::DaliException e) {
29778       {
29779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29780       };
29781     } catch (...) {
29782       {
29783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29784       };
29785     }
29786   }
29787
29788 }
29789
29790
29791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29792   void * jresult ;
29793   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29794   Dali::TouchData *arg2 = 0 ;
29795   Dali::TouchData *result = 0 ;
29796
29797   arg1 = (Dali::TouchData *)jarg1;
29798   arg2 = (Dali::TouchData *)jarg2;
29799   if (!arg2) {
29800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29801     return 0;
29802   }
29803   {
29804     try {
29805       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29806     } catch (std::out_of_range& e) {
29807       {
29808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29809       };
29810     } catch (std::exception& e) {
29811       {
29812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29813       };
29814     } catch (Dali::DaliException e) {
29815       {
29816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29817       };
29818     } catch (...) {
29819       {
29820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29821       };
29822     }
29823   }
29824
29825   jresult = (void *)result;
29826   return jresult;
29827 }
29828
29829
29830 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29831   unsigned long jresult ;
29832   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29833   unsigned long result;
29834
29835   arg1 = (Dali::TouchData *)jarg1;
29836   {
29837     try {
29838       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29839     } catch (std::out_of_range& e) {
29840       {
29841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29842       };
29843     } catch (std::exception& e) {
29844       {
29845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29846       };
29847     } catch (Dali::DaliException e) {
29848       {
29849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29850       };
29851     } catch (...) {
29852       {
29853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29854       };
29855     }
29856   }
29857
29858   jresult = (unsigned long)result;
29859   return jresult;
29860 }
29861
29862
29863 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29864   unsigned long jresult ;
29865   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29866   std::size_t result;
29867
29868   arg1 = (Dali::TouchData *)jarg1;
29869   {
29870     try {
29871       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29872     } catch (std::out_of_range& e) {
29873       {
29874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29875       };
29876     } catch (std::exception& e) {
29877       {
29878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29879       };
29880     } catch (Dali::DaliException e) {
29881       {
29882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29883       };
29884     } catch (...) {
29885       {
29886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29887       };
29888     }
29889   }
29890
29891   jresult = (unsigned long)result;
29892   return jresult;
29893 }
29894
29895
29896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29897   int jresult ;
29898   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29899   std::size_t arg2 ;
29900   int32_t result;
29901
29902   arg1 = (Dali::TouchData *)jarg1;
29903   arg2 = (std::size_t)jarg2;
29904   {
29905     try {
29906       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29907     } catch (std::out_of_range& e) {
29908       {
29909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29910       };
29911     } catch (std::exception& e) {
29912       {
29913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29914       };
29915     } catch (Dali::DaliException e) {
29916       {
29917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29918       };
29919     } catch (...) {
29920       {
29921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29922       };
29923     }
29924   }
29925
29926   jresult = result;
29927   return jresult;
29928 }
29929
29930
29931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29932   int jresult ;
29933   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29934   std::size_t arg2 ;
29935   Dali::PointState::Type result;
29936
29937   arg1 = (Dali::TouchData *)jarg1;
29938   arg2 = (std::size_t)jarg2;
29939   {
29940     try {
29941       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29942     } catch (std::out_of_range& e) {
29943       {
29944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29945       };
29946     } catch (std::exception& e) {
29947       {
29948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29949       };
29950     } catch (Dali::DaliException e) {
29951       {
29952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29953       };
29954     } catch (...) {
29955       {
29956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29957       };
29958     }
29959   }
29960
29961   jresult = (int)result;
29962   return jresult;
29963 }
29964
29965
29966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29967   void * jresult ;
29968   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29969   std::size_t arg2 ;
29970   Dali::Actor result;
29971
29972   arg1 = (Dali::TouchData *)jarg1;
29973   arg2 = (std::size_t)jarg2;
29974   {
29975     try {
29976       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29977     } catch (std::out_of_range& e) {
29978       {
29979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29980       };
29981     } catch (std::exception& e) {
29982       {
29983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29984       };
29985     } catch (Dali::DaliException e) {
29986       {
29987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29988       };
29989     } catch (...) {
29990       {
29991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29992       };
29993     }
29994   }
29995
29996   jresult = new Dali::Actor((const Dali::Actor &)result);
29997   return jresult;
29998 }
29999
30000
30001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30002   void * jresult ;
30003   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30004   std::size_t arg2 ;
30005   Dali::Vector2 *result = 0 ;
30006
30007   arg1 = (Dali::TouchData *)jarg1;
30008   arg2 = (std::size_t)jarg2;
30009   {
30010     try {
30011       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30012     } catch (std::out_of_range& e) {
30013       {
30014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30015       };
30016     } catch (std::exception& e) {
30017       {
30018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30019       };
30020     } catch (Dali::DaliException e) {
30021       {
30022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30023       };
30024     } catch (...) {
30025       {
30026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30027       };
30028     }
30029   }
30030
30031   jresult = (void *)result;
30032   return jresult;
30033 }
30034
30035
30036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30037   void * jresult ;
30038   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30039   std::size_t arg2 ;
30040   Dali::Vector2 *result = 0 ;
30041
30042   arg1 = (Dali::TouchData *)jarg1;
30043   arg2 = (std::size_t)jarg2;
30044   {
30045     try {
30046       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30047     } catch (std::out_of_range& e) {
30048       {
30049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30050       };
30051     } catch (std::exception& e) {
30052       {
30053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30054       };
30055     } catch (Dali::DaliException e) {
30056       {
30057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30058       };
30059     } catch (...) {
30060       {
30061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30062       };
30063     }
30064   }
30065
30066   jresult = (void *)result;
30067   return jresult;
30068 }
30069
30070
30071 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30072   float jresult ;
30073   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30074   std::size_t arg2 ;
30075   float result;
30076
30077   arg1 = (Dali::TouchData *)jarg1;
30078   arg2 = (std::size_t)jarg2;
30079   {
30080     try {
30081       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30082     } catch (std::out_of_range& e) {
30083       {
30084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30085       };
30086     } catch (std::exception& e) {
30087       {
30088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30089       };
30090     } catch (Dali::DaliException e) {
30091       {
30092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30093       };
30094     } catch (...) {
30095       {
30096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30097       };
30098     }
30099   }
30100
30101   jresult = result;
30102   return jresult;
30103 }
30104
30105
30106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30107   void * jresult ;
30108   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30109   std::size_t arg2 ;
30110   Dali::Vector2 *result = 0 ;
30111
30112   arg1 = (Dali::TouchData *)jarg1;
30113   arg2 = (std::size_t)jarg2;
30114   {
30115     try {
30116       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30117     } catch (std::out_of_range& e) {
30118       {
30119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30120       };
30121     } catch (std::exception& e) {
30122       {
30123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30124       };
30125     } catch (Dali::DaliException e) {
30126       {
30127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30128       };
30129     } catch (...) {
30130       {
30131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30132       };
30133     }
30134   }
30135
30136   jresult = (void *)result;
30137   return jresult;
30138 }
30139
30140
30141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30142   float jresult ;
30143   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30144   std::size_t arg2 ;
30145   float result;
30146
30147   arg1 = (Dali::TouchData *)jarg1;
30148   arg2 = (std::size_t)jarg2;
30149   {
30150     try {
30151       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30152     } catch (std::out_of_range& e) {
30153       {
30154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30155       };
30156     } catch (std::exception& e) {
30157       {
30158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30159       };
30160     } catch (Dali::DaliException e) {
30161       {
30162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30163       };
30164     } catch (...) {
30165       {
30166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30167       };
30168     }
30169   }
30170
30171   jresult = result;
30172   return jresult;
30173 }
30174
30175
30176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30177   void * jresult ;
30178   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30179   std::size_t arg2 ;
30180   Dali::Degree result;
30181
30182   arg1 = (Dali::TouchData *)jarg1;
30183   arg2 = (std::size_t)jarg2;
30184   {
30185     try {
30186       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30187     } catch (std::out_of_range& e) {
30188       {
30189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30190       };
30191     } catch (std::exception& e) {
30192       {
30193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30194       };
30195     } catch (Dali::DaliException e) {
30196       {
30197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30198       };
30199     } catch (...) {
30200       {
30201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30202       };
30203     }
30204   }
30205
30206   jresult = new Dali::Degree((const Dali::Degree &)result);
30207   return jresult;
30208 }
30209
30210
30211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30212   int jresult ;
30213   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30214   std::size_t arg2 ;
30215   Dali::MouseButton::Type result;
30216
30217   arg1 = (Dali::TouchData *)jarg1;
30218   arg2 = (std::size_t)jarg2;
30219   {
30220     try {
30221       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30222     } catch (std::out_of_range& e) {
30223       {
30224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30225       };
30226     } catch (std::exception& e) {
30227       {
30228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30229       };
30230     } catch (Dali::DaliException e) {
30231       {
30232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30233       };
30234     } catch (...) {
30235       {
30236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30237       };
30238     }
30239   }
30240
30241   jresult = static_cast< int >(result);
30242   return jresult;
30243 }
30244
30245
30246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30247   void * jresult ;
30248   Dali::GestureDetector *result = 0 ;
30249
30250   {
30251     try {
30252       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30253     } catch (std::out_of_range& e) {
30254       {
30255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30256       };
30257     } catch (std::exception& e) {
30258       {
30259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30260       };
30261     } catch (Dali::DaliException e) {
30262       {
30263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30264       };
30265     } catch (...) {
30266       {
30267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30268       };
30269     }
30270   }
30271
30272   jresult = (void *)result;
30273   return jresult;
30274 }
30275
30276
30277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30278   void * jresult ;
30279   Dali::BaseHandle arg1 ;
30280   Dali::BaseHandle *argp1 ;
30281   Dali::GestureDetector result;
30282
30283   argp1 = (Dali::BaseHandle *)jarg1;
30284   if (!argp1) {
30285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30286     return 0;
30287   }
30288   arg1 = *argp1;
30289   {
30290     try {
30291       result = Dali::GestureDetector::DownCast(arg1);
30292     } catch (std::out_of_range& e) {
30293       {
30294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30295       };
30296     } catch (std::exception& e) {
30297       {
30298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30299       };
30300     } catch (Dali::DaliException e) {
30301       {
30302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30303       };
30304     } catch (...) {
30305       {
30306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30307       };
30308     }
30309   }
30310
30311   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30312   return jresult;
30313 }
30314
30315
30316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30317   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30318
30319   arg1 = (Dali::GestureDetector *)jarg1;
30320   {
30321     try {
30322       delete arg1;
30323     } catch (std::out_of_range& e) {
30324       {
30325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30326       };
30327     } catch (std::exception& e) {
30328       {
30329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30330       };
30331     } catch (Dali::DaliException e) {
30332       {
30333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30334       };
30335     } catch (...) {
30336       {
30337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30338       };
30339     }
30340   }
30341
30342 }
30343
30344
30345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30346   void * jresult ;
30347   Dali::GestureDetector *arg1 = 0 ;
30348   Dali::GestureDetector *result = 0 ;
30349
30350   arg1 = (Dali::GestureDetector *)jarg1;
30351   if (!arg1) {
30352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30353     return 0;
30354   }
30355   {
30356     try {
30357       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30358     } catch (std::out_of_range& e) {
30359       {
30360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30361       };
30362     } catch (std::exception& e) {
30363       {
30364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30365       };
30366     } catch (Dali::DaliException e) {
30367       {
30368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30369       };
30370     } catch (...) {
30371       {
30372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30373       };
30374     }
30375   }
30376
30377   jresult = (void *)result;
30378   return jresult;
30379 }
30380
30381
30382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30383   void * jresult ;
30384   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30385   Dali::GestureDetector *arg2 = 0 ;
30386   Dali::GestureDetector *result = 0 ;
30387
30388   arg1 = (Dali::GestureDetector *)jarg1;
30389   arg2 = (Dali::GestureDetector *)jarg2;
30390   if (!arg2) {
30391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30392     return 0;
30393   }
30394   {
30395     try {
30396       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30397     } catch (std::out_of_range& e) {
30398       {
30399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30400       };
30401     } catch (std::exception& e) {
30402       {
30403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30404       };
30405     } catch (Dali::DaliException e) {
30406       {
30407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30408       };
30409     } catch (...) {
30410       {
30411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30412       };
30413     }
30414   }
30415
30416   jresult = (void *)result;
30417   return jresult;
30418 }
30419
30420
30421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30422   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30423   Dali::Actor arg2 ;
30424   Dali::Actor *argp2 ;
30425
30426   arg1 = (Dali::GestureDetector *)jarg1;
30427   argp2 = (Dali::Actor *)jarg2;
30428   if (!argp2) {
30429     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30430     return ;
30431   }
30432   arg2 = *argp2;
30433   {
30434     try {
30435       (arg1)->Attach(arg2);
30436     } catch (std::out_of_range& e) {
30437       {
30438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30439       };
30440     } catch (std::exception& e) {
30441       {
30442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30443       };
30444     } catch (Dali::DaliException e) {
30445       {
30446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30447       };
30448     } catch (...) {
30449       {
30450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30451       };
30452     }
30453   }
30454
30455 }
30456
30457
30458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30459   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30460   Dali::Actor arg2 ;
30461   Dali::Actor *argp2 ;
30462
30463   arg1 = (Dali::GestureDetector *)jarg1;
30464   argp2 = (Dali::Actor *)jarg2;
30465   if (!argp2) {
30466     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30467     return ;
30468   }
30469   arg2 = *argp2;
30470   {
30471     try {
30472       (arg1)->Detach(arg2);
30473     } catch (std::out_of_range& e) {
30474       {
30475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30476       };
30477     } catch (std::exception& e) {
30478       {
30479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30480       };
30481     } catch (Dali::DaliException e) {
30482       {
30483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30484       };
30485     } catch (...) {
30486       {
30487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30488       };
30489     }
30490   }
30491
30492 }
30493
30494
30495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30496   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30497
30498   arg1 = (Dali::GestureDetector *)jarg1;
30499   {
30500     try {
30501       (arg1)->DetachAll();
30502     } catch (std::out_of_range& e) {
30503       {
30504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30505       };
30506     } catch (std::exception& e) {
30507       {
30508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30509       };
30510     } catch (Dali::DaliException e) {
30511       {
30512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30513       };
30514     } catch (...) {
30515       {
30516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30517       };
30518     }
30519   }
30520
30521 }
30522
30523
30524 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30525   unsigned long jresult ;
30526   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30527   size_t result;
30528
30529   arg1 = (Dali::GestureDetector *)jarg1;
30530   {
30531     try {
30532       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30533     } catch (std::out_of_range& e) {
30534       {
30535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30536       };
30537     } catch (std::exception& e) {
30538       {
30539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30540       };
30541     } catch (Dali::DaliException e) {
30542       {
30543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30544       };
30545     } catch (...) {
30546       {
30547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30548       };
30549     }
30550   }
30551
30552   jresult = (unsigned long)result;
30553   return jresult;
30554 }
30555
30556
30557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30558   void * jresult ;
30559   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30560   size_t arg2 ;
30561   Dali::Actor result;
30562
30563   arg1 = (Dali::GestureDetector *)jarg1;
30564   arg2 = (size_t)jarg2;
30565   {
30566     try {
30567       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30568     } catch (std::out_of_range& e) {
30569       {
30570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30571       };
30572     } catch (std::exception& e) {
30573       {
30574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30575       };
30576     } catch (Dali::DaliException e) {
30577       {
30578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30579       };
30580     } catch (...) {
30581       {
30582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30583       };
30584     }
30585   }
30586
30587   jresult = new Dali::Actor((const Dali::Actor &)result);
30588   return jresult;
30589 }
30590
30591
30592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30593   void * jresult ;
30594   Dali::Gesture *arg1 = 0 ;
30595   Dali::Gesture *result = 0 ;
30596
30597   arg1 = (Dali::Gesture *)jarg1;
30598   if (!arg1) {
30599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30600     return 0;
30601   }
30602   {
30603     try {
30604       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30605     } catch (std::out_of_range& e) {
30606       {
30607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30608       };
30609     } catch (std::exception& e) {
30610       {
30611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30612       };
30613     } catch (Dali::DaliException e) {
30614       {
30615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30616       };
30617     } catch (...) {
30618       {
30619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30620       };
30621     }
30622   }
30623
30624   jresult = (void *)result;
30625   return jresult;
30626 }
30627
30628
30629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30630   void * jresult ;
30631   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30632   Dali::Gesture *arg2 = 0 ;
30633   Dali::Gesture *result = 0 ;
30634
30635   arg1 = (Dali::Gesture *)jarg1;
30636   arg2 = (Dali::Gesture *)jarg2;
30637   if (!arg2) {
30638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30639     return 0;
30640   }
30641   {
30642     try {
30643       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30644     } catch (std::out_of_range& e) {
30645       {
30646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30647       };
30648     } catch (std::exception& e) {
30649       {
30650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30651       };
30652     } catch (Dali::DaliException e) {
30653       {
30654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30655       };
30656     } catch (...) {
30657       {
30658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30659       };
30660     }
30661   }
30662
30663   jresult = (void *)result;
30664   return jresult;
30665 }
30666
30667
30668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30669   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30670
30671   arg1 = (Dali::Gesture *)jarg1;
30672   {
30673     try {
30674       delete arg1;
30675     } catch (std::out_of_range& e) {
30676       {
30677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30678       };
30679     } catch (std::exception& e) {
30680       {
30681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30682       };
30683     } catch (Dali::DaliException e) {
30684       {
30685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30686       };
30687     } catch (...) {
30688       {
30689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30690       };
30691     }
30692   }
30693
30694 }
30695
30696
30697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30698   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30699   Dali::Gesture::Type arg2 ;
30700
30701   arg1 = (Dali::Gesture *)jarg1;
30702   arg2 = (Dali::Gesture::Type)jarg2;
30703   if (arg1) (arg1)->type = arg2;
30704 }
30705
30706
30707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30708   int jresult ;
30709   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30710   Dali::Gesture::Type result;
30711
30712   arg1 = (Dali::Gesture *)jarg1;
30713   result = (Dali::Gesture::Type) ((arg1)->type);
30714   jresult = (int)result;
30715   return jresult;
30716 }
30717
30718
30719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30720   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30721   Dali::Gesture::State arg2 ;
30722
30723   arg1 = (Dali::Gesture *)jarg1;
30724   arg2 = (Dali::Gesture::State)jarg2;
30725   if (arg1) (arg1)->state = arg2;
30726 }
30727
30728
30729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30730   int jresult ;
30731   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30732   Dali::Gesture::State result;
30733
30734   arg1 = (Dali::Gesture *)jarg1;
30735   result = (Dali::Gesture::State) ((arg1)->state);
30736   jresult = (int)result;
30737   return jresult;
30738 }
30739
30740
30741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30742   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30743   unsigned int arg2 ;
30744
30745   arg1 = (Dali::Gesture *)jarg1;
30746   arg2 = (unsigned int)jarg2;
30747   if (arg1) (arg1)->time = arg2;
30748 }
30749
30750
30751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30752   unsigned int jresult ;
30753   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30754   unsigned int result;
30755
30756   arg1 = (Dali::Gesture *)jarg1;
30757   result = (unsigned int) ((arg1)->time);
30758   jresult = result;
30759   return jresult;
30760 }
30761
30762
30763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30764   void * jresult ;
30765   Dali::HoverEvent *result = 0 ;
30766
30767   {
30768     try {
30769       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30770     } catch (std::out_of_range& e) {
30771       {
30772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30773       };
30774     } catch (std::exception& e) {
30775       {
30776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30777       };
30778     } catch (Dali::DaliException e) {
30779       {
30780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30781       };
30782     } catch (...) {
30783       {
30784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30785       };
30786     }
30787   }
30788
30789   jresult = (void *)result;
30790   return jresult;
30791 }
30792
30793
30794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30795   void * jresult ;
30796   unsigned long arg1 ;
30797   Dali::HoverEvent *result = 0 ;
30798
30799   arg1 = (unsigned long)jarg1;
30800   {
30801     try {
30802       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30803     } catch (std::out_of_range& e) {
30804       {
30805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30806       };
30807     } catch (std::exception& e) {
30808       {
30809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30810       };
30811     } catch (Dali::DaliException e) {
30812       {
30813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30814       };
30815     } catch (...) {
30816       {
30817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30818       };
30819     }
30820   }
30821
30822   jresult = (void *)result;
30823   return jresult;
30824 }
30825
30826
30827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30828   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30829
30830   arg1 = (Dali::HoverEvent *)jarg1;
30831   {
30832     try {
30833       delete arg1;
30834     } catch (std::out_of_range& e) {
30835       {
30836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30837       };
30838     } catch (std::exception& e) {
30839       {
30840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30841       };
30842     } catch (Dali::DaliException e) {
30843       {
30844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30845       };
30846     } catch (...) {
30847       {
30848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30849       };
30850     }
30851   }
30852
30853 }
30854
30855
30856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30857   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30858   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30859
30860   arg1 = (Dali::HoverEvent *)jarg1;
30861   arg2 = (Dali::TouchPointContainer *)jarg2;
30862   if (arg1) (arg1)->points = *arg2;
30863 }
30864
30865
30866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30867   void * jresult ;
30868   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30869   Dali::TouchPointContainer *result = 0 ;
30870
30871   arg1 = (Dali::HoverEvent *)jarg1;
30872   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30873   jresult = (void *)result;
30874   return jresult;
30875 }
30876
30877
30878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30879   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30880   unsigned long arg2 ;
30881
30882   arg1 = (Dali::HoverEvent *)jarg1;
30883   arg2 = (unsigned long)jarg2;
30884   if (arg1) (arg1)->time = arg2;
30885 }
30886
30887
30888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30889   unsigned long jresult ;
30890   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30891   unsigned long result;
30892
30893   arg1 = (Dali::HoverEvent *)jarg1;
30894   result = (unsigned long) ((arg1)->time);
30895   jresult = (unsigned long)result;
30896   return jresult;
30897 }
30898
30899
30900 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30901   unsigned int jresult ;
30902   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30903   unsigned int result;
30904
30905   arg1 = (Dali::HoverEvent *)jarg1;
30906   {
30907     try {
30908       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30909     } catch (std::out_of_range& e) {
30910       {
30911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30912       };
30913     } catch (std::exception& e) {
30914       {
30915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30916       };
30917     } catch (Dali::DaliException e) {
30918       {
30919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30920       };
30921     } catch (...) {
30922       {
30923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30924       };
30925     }
30926   }
30927
30928   jresult = result;
30929   return jresult;
30930 }
30931
30932
30933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30934   void * jresult ;
30935   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30936   unsigned int arg2 ;
30937   Dali::TouchPoint *result = 0 ;
30938
30939   arg1 = (Dali::HoverEvent *)jarg1;
30940   arg2 = (unsigned int)jarg2;
30941   {
30942     try {
30943       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30944     } catch (std::out_of_range& e) {
30945       {
30946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30947       };
30948     } catch (std::exception& e) {
30949       {
30950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30951       };
30952     } catch (Dali::DaliException e) {
30953       {
30954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30955       };
30956     } catch (...) {
30957       {
30958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30959       };
30960     }
30961   }
30962
30963   jresult = (void *)result;
30964   return jresult;
30965 }
30966
30967
30968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30969   void * jresult ;
30970   Dali::KeyEvent *result = 0 ;
30971
30972   {
30973     try {
30974       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30975     } catch (std::out_of_range& e) {
30976       {
30977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30978       };
30979     } catch (std::exception& e) {
30980       {
30981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30982       };
30983     } catch (Dali::DaliException e) {
30984       {
30985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30986       };
30987     } catch (...) {
30988       {
30989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30990       };
30991     }
30992   }
30993
30994   jresult = (void *)result;
30995   return jresult;
30996 }
30997
30998
30999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31000   void * jresult ;
31001   std::string *arg1 = 0 ;
31002   std::string *arg2 = 0 ;
31003   int arg3 ;
31004   int arg4 ;
31005   unsigned long arg5 ;
31006   Dali::KeyEvent::State *arg6 = 0 ;
31007   Dali::KeyEvent::State temp6 ;
31008   Dali::KeyEvent *result = 0 ;
31009
31010   if (!jarg1) {
31011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31012     return 0;
31013   }
31014   std::string arg1_str(jarg1);
31015   arg1 = &arg1_str;
31016   if (!jarg2) {
31017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31018     return 0;
31019   }
31020   std::string arg2_str(jarg2);
31021   arg2 = &arg2_str;
31022   arg3 = (int)jarg3;
31023   arg4 = (int)jarg4;
31024   arg5 = (unsigned long)jarg5;
31025   temp6 = (Dali::KeyEvent::State)jarg6;
31026   arg6 = &temp6;
31027   {
31028     try {
31029       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31030     } catch (std::out_of_range& e) {
31031       {
31032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31033       };
31034     } catch (std::exception& e) {
31035       {
31036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31037       };
31038     } catch (Dali::DaliException e) {
31039       {
31040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31041       };
31042     } catch (...) {
31043       {
31044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31045       };
31046     }
31047   }
31048
31049   jresult = (void *)result;
31050
31051   //argout typemap for const std::string&
31052
31053
31054   //argout typemap for const std::string&
31055
31056   return jresult;
31057 }
31058
31059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31060   void * jresult ;
31061   Dali::KeyEvent *arg1 = 0 ;
31062   Dali::KeyEvent *result = 0 ;
31063
31064   arg1 = (Dali::KeyEvent *)jarg1;
31065   if (!arg1) {
31066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31067     return 0;
31068   }
31069   {
31070     try {
31071       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31072     } catch (std::out_of_range& e) {
31073       {
31074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31075       };
31076     } catch (std::exception& e) {
31077       {
31078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31079       };
31080     } catch (Dali::DaliException e) {
31081       {
31082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31083       };
31084     } catch (...) {
31085       {
31086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31087       };
31088     }
31089   }
31090
31091   jresult = (void *)result;
31092   return jresult;
31093 }
31094
31095
31096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31097   void * jresult ;
31098   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31099   Dali::KeyEvent *arg2 = 0 ;
31100   Dali::KeyEvent *result = 0 ;
31101
31102   arg1 = (Dali::KeyEvent *)jarg1;
31103   arg2 = (Dali::KeyEvent *)jarg2;
31104   if (!arg2) {
31105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31106     return 0;
31107   }
31108   {
31109     try {
31110       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31111     } catch (std::out_of_range& e) {
31112       {
31113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31114       };
31115     } catch (std::exception& e) {
31116       {
31117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31118       };
31119     } catch (Dali::DaliException e) {
31120       {
31121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31122       };
31123     } catch (...) {
31124       {
31125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31126       };
31127     }
31128   }
31129
31130   jresult = (void *)result;
31131   return jresult;
31132 }
31133
31134
31135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31136   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31137
31138   arg1 = (Dali::KeyEvent *)jarg1;
31139   {
31140     try {
31141       delete arg1;
31142     } catch (std::out_of_range& e) {
31143       {
31144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31145       };
31146     } catch (std::exception& e) {
31147       {
31148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31149       };
31150     } catch (Dali::DaliException e) {
31151       {
31152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31153       };
31154     } catch (...) {
31155       {
31156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31157       };
31158     }
31159   }
31160
31161 }
31162
31163
31164 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31165   unsigned int jresult ;
31166   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31167   bool result;
31168
31169   arg1 = (Dali::KeyEvent *)jarg1;
31170   {
31171     try {
31172       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31173     } catch (std::out_of_range& e) {
31174       {
31175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31176       };
31177     } catch (std::exception& e) {
31178       {
31179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31180       };
31181     } catch (Dali::DaliException e) {
31182       {
31183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31184       };
31185     } catch (...) {
31186       {
31187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31188       };
31189     }
31190   }
31191
31192   jresult = result;
31193   return jresult;
31194 }
31195
31196
31197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31198   unsigned int jresult ;
31199   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31200   bool result;
31201
31202   arg1 = (Dali::KeyEvent *)jarg1;
31203   {
31204     try {
31205       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31206     } catch (std::out_of_range& e) {
31207       {
31208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31209       };
31210     } catch (std::exception& e) {
31211       {
31212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31213       };
31214     } catch (Dali::DaliException e) {
31215       {
31216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31217       };
31218     } catch (...) {
31219       {
31220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31221       };
31222     }
31223   }
31224
31225   jresult = result;
31226   return jresult;
31227 }
31228
31229
31230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31231   unsigned int jresult ;
31232   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31233   bool result;
31234
31235   arg1 = (Dali::KeyEvent *)jarg1;
31236   {
31237     try {
31238       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31239     } catch (std::out_of_range& e) {
31240       {
31241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31242       };
31243     } catch (std::exception& e) {
31244       {
31245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31246       };
31247     } catch (Dali::DaliException e) {
31248       {
31249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31250       };
31251     } catch (...) {
31252       {
31253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31254       };
31255     }
31256   }
31257
31258   jresult = result;
31259   return jresult;
31260 }
31261
31262
31263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31264   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31265   std::string *arg2 = 0 ;
31266
31267   arg1 = (Dali::KeyEvent *)jarg1;
31268   if (!jarg2) {
31269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31270     return ;
31271   }
31272   std::string arg2_str(jarg2);
31273   arg2 = &arg2_str;
31274   if (arg1) (arg1)->keyPressedName = *arg2;
31275
31276   //argout typemap for const std::string&
31277
31278 }
31279
31280
31281 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31282   char * jresult ;
31283
31284   if( jarg1 == NULL )
31285   {
31286     jresult = SWIG_csharp_string_callback( "" );
31287   }
31288   else
31289   {
31290     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31291     std::string *result = 0;
31292
31293     arg1 = ( Dali::KeyEvent * )jarg1;
31294     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31295     jresult = SWIG_csharp_string_callback( result->c_str() );
31296   }
31297
31298   return jresult;
31299 }
31300
31301
31302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31303   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31304   std::string *arg2 = 0 ;
31305
31306   arg1 = (Dali::KeyEvent *)jarg1;
31307   if (!jarg2) {
31308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31309     return ;
31310   }
31311   std::string arg2_str(jarg2);
31312   arg2 = &arg2_str;
31313   if (arg1) (arg1)->keyPressed = *arg2;
31314
31315   //argout typemap for const std::string&
31316
31317 }
31318
31319
31320 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31321   char * jresult ;
31322   if( NULL == jarg1 )
31323   {
31324     jresult = SWIG_csharp_string_callback( "" );
31325   }
31326   else
31327   {
31328     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31329     std::string *result = 0;
31330
31331     arg1 = ( Dali::KeyEvent * )jarg1;
31332     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31333     jresult = SWIG_csharp_string_callback( result->c_str() );
31334   }
31335   return jresult;
31336 }
31337
31338
31339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31340   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31341   int arg2 ;
31342
31343   arg1 = (Dali::KeyEvent *)jarg1;
31344   arg2 = (int)jarg2;
31345   if (arg1) (arg1)->keyCode = arg2;
31346 }
31347
31348
31349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31350   int jresult ;
31351   if( NULL == jarg1 )
31352   {
31353     jresult = -1;
31354   }
31355   else
31356   {
31357     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31358     int result;
31359
31360     arg1 = ( Dali::KeyEvent * )jarg1;
31361     result = (int)( ( arg1 )->keyCode );
31362     jresult = result;
31363   }
31364   return jresult;
31365 }
31366
31367
31368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31369   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31370   int arg2 ;
31371
31372   arg1 = (Dali::KeyEvent *)jarg1;
31373   arg2 = (int)jarg2;
31374   if (arg1) (arg1)->keyModifier = arg2;
31375 }
31376
31377
31378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31379   int jresult ;
31380   if( jarg1 == NULL )
31381   {
31382     jresult = -1;
31383   }
31384   else
31385   {
31386     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31387     int result;
31388
31389     arg1 = ( Dali::KeyEvent * )jarg1;
31390     result = (int)( ( arg1 )->keyModifier );
31391     jresult = result;
31392   }
31393   return jresult;
31394 }
31395
31396
31397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31398   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31399   unsigned long arg2 ;
31400
31401   arg1 = (Dali::KeyEvent *)jarg1;
31402   arg2 = (unsigned long)jarg2;
31403   if (arg1) (arg1)->time = arg2;
31404 }
31405
31406
31407 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31408   unsigned long jresult ;
31409   if( jarg1 == NULL )
31410   {
31411     jresult = 0;
31412   }
31413   else
31414   {
31415     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31416     unsigned long result;
31417
31418     arg1 = ( Dali::KeyEvent * )jarg1;
31419     result = (unsigned long)( ( arg1 )->time );
31420     jresult = (unsigned long)result;
31421   }
31422   return jresult;
31423 }
31424
31425
31426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31427   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31428   Dali::KeyEvent::State arg2 ;
31429
31430   arg1 = (Dali::KeyEvent *)jarg1;
31431   arg2 = (Dali::KeyEvent::State)jarg2;
31432   if (arg1) (arg1)->state = arg2;
31433 }
31434
31435
31436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31437   int jresult ;
31438   if( jarg1 == NULL )
31439   {
31440     jresult = -1;
31441   }
31442   else
31443   {
31444     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31445     Dali::KeyEvent::State result;
31446
31447     arg1 = ( Dali::KeyEvent * )jarg1;
31448     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31449     jresult = (int)result;
31450   }
31451   return jresult;
31452 }
31453
31454
31455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31456   void * jresult ;
31457   Dali::LongPressGestureDetector *result = 0 ;
31458
31459   {
31460     try {
31461       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31462     } catch (std::out_of_range& e) {
31463       {
31464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31465       };
31466     } catch (std::exception& e) {
31467       {
31468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31469       };
31470     } catch (Dali::DaliException e) {
31471       {
31472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31473       };
31474     } catch (...) {
31475       {
31476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31477       };
31478     }
31479   }
31480
31481   jresult = (void *)result;
31482   return jresult;
31483 }
31484
31485
31486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31487   void * jresult ;
31488   Dali::LongPressGestureDetector result;
31489
31490   {
31491     try {
31492       result = Dali::LongPressGestureDetector::New();
31493     } catch (std::out_of_range& e) {
31494       {
31495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31496       };
31497     } catch (std::exception& e) {
31498       {
31499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31500       };
31501     } catch (Dali::DaliException e) {
31502       {
31503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31504       };
31505     } catch (...) {
31506       {
31507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31508       };
31509     }
31510   }
31511
31512   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31513   return jresult;
31514 }
31515
31516
31517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31518   void * jresult ;
31519   unsigned int arg1 ;
31520   Dali::LongPressGestureDetector result;
31521
31522   arg1 = (unsigned int)jarg1;
31523   {
31524     try {
31525       result = Dali::LongPressGestureDetector::New(arg1);
31526     } catch (std::out_of_range& e) {
31527       {
31528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31529       };
31530     } catch (std::exception& e) {
31531       {
31532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31533       };
31534     } catch (Dali::DaliException e) {
31535       {
31536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31537       };
31538     } catch (...) {
31539       {
31540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31541       };
31542     }
31543   }
31544
31545   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31546   return jresult;
31547 }
31548
31549
31550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31551   void * jresult ;
31552   unsigned int arg1 ;
31553   unsigned int arg2 ;
31554   Dali::LongPressGestureDetector result;
31555
31556   arg1 = (unsigned int)jarg1;
31557   arg2 = (unsigned int)jarg2;
31558   {
31559     try {
31560       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31561     } catch (std::out_of_range& e) {
31562       {
31563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31564       };
31565     } catch (std::exception& e) {
31566       {
31567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31568       };
31569     } catch (Dali::DaliException e) {
31570       {
31571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31572       };
31573     } catch (...) {
31574       {
31575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31576       };
31577     }
31578   }
31579
31580   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31581   return jresult;
31582 }
31583
31584
31585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31586   void * jresult ;
31587   Dali::BaseHandle arg1 ;
31588   Dali::BaseHandle *argp1 ;
31589   Dali::LongPressGestureDetector result;
31590
31591   argp1 = (Dali::BaseHandle *)jarg1;
31592   if (!argp1) {
31593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31594     return 0;
31595   }
31596   arg1 = *argp1;
31597   {
31598     try {
31599       result = Dali::LongPressGestureDetector::DownCast(arg1);
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_delete_LongPressGestureDetector(void * jarg1) {
31625   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31626
31627   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31628   {
31629     try {
31630       delete arg1;
31631     } catch (std::out_of_range& e) {
31632       {
31633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31634       };
31635     } catch (std::exception& e) {
31636       {
31637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31638       };
31639     } catch (Dali::DaliException e) {
31640       {
31641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31642       };
31643     } catch (...) {
31644       {
31645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31646       };
31647     }
31648   }
31649
31650 }
31651
31652
31653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31654   void * jresult ;
31655   Dali::LongPressGestureDetector *arg1 = 0 ;
31656   Dali::LongPressGestureDetector *result = 0 ;
31657
31658   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31659   if (!arg1) {
31660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31661     return 0;
31662   }
31663   {
31664     try {
31665       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31666     } catch (std::out_of_range& e) {
31667       {
31668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31669       };
31670     } catch (std::exception& e) {
31671       {
31672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31673       };
31674     } catch (Dali::DaliException e) {
31675       {
31676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31677       };
31678     } catch (...) {
31679       {
31680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31681       };
31682     }
31683   }
31684
31685   jresult = (void *)result;
31686   return jresult;
31687 }
31688
31689
31690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31691   void * jresult ;
31692   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31693   Dali::LongPressGestureDetector *arg2 = 0 ;
31694   Dali::LongPressGestureDetector *result = 0 ;
31695
31696   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31697   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31698   if (!arg2) {
31699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31700     return 0;
31701   }
31702   {
31703     try {
31704       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
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_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31730   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31731   unsigned int arg2 ;
31732
31733   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31734   arg2 = (unsigned int)jarg2;
31735   {
31736     try {
31737       (arg1)->SetTouchesRequired(arg2);
31738     } catch (std::out_of_range& e) {
31739       {
31740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31741       };
31742     } catch (std::exception& e) {
31743       {
31744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31745       };
31746     } catch (Dali::DaliException e) {
31747       {
31748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31749       };
31750     } catch (...) {
31751       {
31752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31753       };
31754     }
31755   }
31756
31757 }
31758
31759
31760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31761   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31762   unsigned int arg2 ;
31763   unsigned int arg3 ;
31764
31765   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31766   arg2 = (unsigned int)jarg2;
31767   arg3 = (unsigned int)jarg3;
31768   {
31769     try {
31770       (arg1)->SetTouchesRequired(arg2,arg3);
31771     } catch (std::out_of_range& e) {
31772       {
31773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31774       };
31775     } catch (std::exception& e) {
31776       {
31777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31778       };
31779     } catch (Dali::DaliException e) {
31780       {
31781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31782       };
31783     } catch (...) {
31784       {
31785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31786       };
31787     }
31788   }
31789
31790 }
31791
31792
31793 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31794   unsigned int jresult ;
31795   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31796   unsigned int result;
31797
31798   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31799   {
31800     try {
31801       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31802     } catch (std::out_of_range& e) {
31803       {
31804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31805       };
31806     } catch (std::exception& e) {
31807       {
31808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31809       };
31810     } catch (Dali::DaliException e) {
31811       {
31812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31813       };
31814     } catch (...) {
31815       {
31816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31817       };
31818     }
31819   }
31820
31821   jresult = result;
31822   return jresult;
31823 }
31824
31825
31826 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31827   unsigned int jresult ;
31828   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31829   unsigned int result;
31830
31831   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31832   {
31833     try {
31834       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31835     } catch (std::out_of_range& e) {
31836       {
31837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31838       };
31839     } catch (std::exception& e) {
31840       {
31841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31842       };
31843     } catch (Dali::DaliException e) {
31844       {
31845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31846       };
31847     } catch (...) {
31848       {
31849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31850       };
31851     }
31852   }
31853
31854   jresult = result;
31855   return jresult;
31856 }
31857
31858
31859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31860   void * jresult ;
31861   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31862   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31863
31864   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31865   {
31866     try {
31867       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31868     } catch (std::out_of_range& e) {
31869       {
31870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31871       };
31872     } catch (std::exception& e) {
31873       {
31874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31875       };
31876     } catch (Dali::DaliException e) {
31877       {
31878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31879       };
31880     } catch (...) {
31881       {
31882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31883       };
31884     }
31885   }
31886
31887   jresult = (void *)result;
31888   return jresult;
31889 }
31890
31891
31892 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31893   void * jresult ;
31894   Dali::Gesture::State arg1 ;
31895   Dali::LongPressGesture *result = 0 ;
31896
31897   arg1 = (Dali::Gesture::State)jarg1;
31898   {
31899     try {
31900       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31901     } catch (std::out_of_range& e) {
31902       {
31903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31904       };
31905     } catch (std::exception& e) {
31906       {
31907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31908       };
31909     } catch (Dali::DaliException e) {
31910       {
31911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31912       };
31913     } catch (...) {
31914       {
31915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31916       };
31917     }
31918   }
31919
31920   jresult = (void *)result;
31921   return jresult;
31922 }
31923
31924
31925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31926   void * jresult ;
31927   Dali::LongPressGesture *arg1 = 0 ;
31928   Dali::LongPressGesture *result = 0 ;
31929
31930   arg1 = (Dali::LongPressGesture *)jarg1;
31931   if (!arg1) {
31932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31933     return 0;
31934   }
31935   {
31936     try {
31937       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31938     } catch (std::out_of_range& e) {
31939       {
31940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31941       };
31942     } catch (std::exception& e) {
31943       {
31944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31945       };
31946     } catch (Dali::DaliException e) {
31947       {
31948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31949       };
31950     } catch (...) {
31951       {
31952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31953       };
31954     }
31955   }
31956
31957   jresult = (void *)result;
31958   return jresult;
31959 }
31960
31961
31962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31963   void * jresult ;
31964   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31965   Dali::LongPressGesture *arg2 = 0 ;
31966   Dali::LongPressGesture *result = 0 ;
31967
31968   arg1 = (Dali::LongPressGesture *)jarg1;
31969   arg2 = (Dali::LongPressGesture *)jarg2;
31970   if (!arg2) {
31971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31972     return 0;
31973   }
31974   {
31975     try {
31976       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
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_delete_LongPressGesture(void * jarg1) {
32002   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32003
32004   arg1 = (Dali::LongPressGesture *)jarg1;
32005   {
32006     try {
32007       delete arg1;
32008     } catch (std::out_of_range& e) {
32009       {
32010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32011       };
32012     } catch (std::exception& e) {
32013       {
32014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32015       };
32016     } catch (Dali::DaliException e) {
32017       {
32018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32019       };
32020     } catch (...) {
32021       {
32022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32023       };
32024     }
32025   }
32026
32027 }
32028
32029
32030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32031   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32032   unsigned int arg2 ;
32033
32034   arg1 = (Dali::LongPressGesture *)jarg1;
32035   arg2 = (unsigned int)jarg2;
32036   if (arg1) (arg1)->numberOfTouches = arg2;
32037 }
32038
32039
32040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32041   unsigned int jresult ;
32042   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32043   unsigned int result;
32044
32045   arg1 = (Dali::LongPressGesture *)jarg1;
32046   result = (unsigned int) ((arg1)->numberOfTouches);
32047   jresult = result;
32048   return jresult;
32049 }
32050
32051
32052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32053   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32054   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32055
32056   arg1 = (Dali::LongPressGesture *)jarg1;
32057   arg2 = (Dali::Vector2 *)jarg2;
32058   if (arg1) (arg1)->screenPoint = *arg2;
32059 }
32060
32061
32062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32063   void * jresult ;
32064   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32065   Dali::Vector2 *result = 0 ;
32066
32067   arg1 = (Dali::LongPressGesture *)jarg1;
32068   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32069   jresult = (void *)result;
32070   return jresult;
32071 }
32072
32073
32074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32075   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32076   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32077
32078   arg1 = (Dali::LongPressGesture *)jarg1;
32079   arg2 = (Dali::Vector2 *)jarg2;
32080   if (arg1) (arg1)->localPoint = *arg2;
32081 }
32082
32083
32084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32085   void * jresult ;
32086   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32087   Dali::Vector2 *result = 0 ;
32088
32089   arg1 = (Dali::LongPressGesture *)jarg1;
32090   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32091   jresult = (void *)result;
32092   return jresult;
32093 }
32094
32095
32096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32097   void * jresult ;
32098   Dali::WheelEvent *result = 0 ;
32099
32100   {
32101     try {
32102       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32103     } catch (std::out_of_range& e) {
32104       {
32105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32106       };
32107     } catch (std::exception& e) {
32108       {
32109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32110       };
32111     } catch (Dali::DaliException e) {
32112       {
32113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32114       };
32115     } catch (...) {
32116       {
32117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32118       };
32119     }
32120   }
32121
32122   jresult = (void *)result;
32123   return jresult;
32124 }
32125
32126
32127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32128   void * jresult ;
32129   Dali::WheelEvent::Type arg1 ;
32130   int arg2 ;
32131   unsigned int arg3 ;
32132   Dali::Vector2 arg4 ;
32133   int arg5 ;
32134   unsigned int arg6 ;
32135   Dali::Vector2 *argp4 ;
32136   Dali::WheelEvent *result = 0 ;
32137
32138   arg1 = (Dali::WheelEvent::Type)jarg1;
32139   arg2 = (int)jarg2;
32140   arg3 = (unsigned int)jarg3;
32141   argp4 = (Dali::Vector2 *)jarg4;
32142   if (!argp4) {
32143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32144     return 0;
32145   }
32146   arg4 = *argp4;
32147   arg5 = (int)jarg5;
32148   arg6 = (unsigned int)jarg6;
32149   {
32150     try {
32151       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32152     } catch (std::out_of_range& e) {
32153       {
32154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32155       };
32156     } catch (std::exception& e) {
32157       {
32158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32159       };
32160     } catch (Dali::DaliException e) {
32161       {
32162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32163       };
32164     } catch (...) {
32165       {
32166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32167       };
32168     }
32169   }
32170
32171   jresult = (void *)result;
32172   return jresult;
32173 }
32174
32175
32176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32177   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32178
32179   arg1 = (Dali::WheelEvent *)jarg1;
32180   {
32181     try {
32182       delete arg1;
32183     } catch (std::out_of_range& e) {
32184       {
32185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32186       };
32187     } catch (std::exception& e) {
32188       {
32189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32190       };
32191     } catch (Dali::DaliException e) {
32192       {
32193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32194       };
32195     } catch (...) {
32196       {
32197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32198       };
32199     }
32200   }
32201
32202 }
32203
32204
32205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32206   unsigned int jresult ;
32207   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32208   bool result;
32209
32210   arg1 = (Dali::WheelEvent *)jarg1;
32211   {
32212     try {
32213       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32214     } catch (std::out_of_range& e) {
32215       {
32216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32217       };
32218     } catch (std::exception& e) {
32219       {
32220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32221       };
32222     } catch (Dali::DaliException e) {
32223       {
32224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32225       };
32226     } catch (...) {
32227       {
32228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32229       };
32230     }
32231   }
32232
32233   jresult = result;
32234   return jresult;
32235 }
32236
32237
32238 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32239   unsigned int jresult ;
32240   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32241   bool result;
32242
32243   arg1 = (Dali::WheelEvent *)jarg1;
32244   {
32245     try {
32246       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32247     } catch (std::out_of_range& e) {
32248       {
32249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32250       };
32251     } catch (std::exception& e) {
32252       {
32253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32254       };
32255     } catch (Dali::DaliException e) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32258       };
32259     } catch (...) {
32260       {
32261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32262       };
32263     }
32264   }
32265
32266   jresult = result;
32267   return jresult;
32268 }
32269
32270
32271 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32272   unsigned int jresult ;
32273   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32274   bool result;
32275
32276   arg1 = (Dali::WheelEvent *)jarg1;
32277   {
32278     try {
32279       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32280     } catch (std::out_of_range& e) {
32281       {
32282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32283       };
32284     } catch (std::exception& e) {
32285       {
32286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32287       };
32288     } catch (Dali::DaliException e) {
32289       {
32290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32291       };
32292     } catch (...) {
32293       {
32294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32295       };
32296     }
32297   }
32298
32299   jresult = result;
32300   return jresult;
32301 }
32302
32303
32304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32305   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32306   Dali::WheelEvent::Type arg2 ;
32307
32308   arg1 = (Dali::WheelEvent *)jarg1;
32309   arg2 = (Dali::WheelEvent::Type)jarg2;
32310   if (arg1) (arg1)->type = arg2;
32311 }
32312
32313
32314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32315   int jresult ;
32316   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32317   Dali::WheelEvent::Type result;
32318
32319   arg1 = (Dali::WheelEvent *)jarg1;
32320   result = (Dali::WheelEvent::Type) ((arg1)->type);
32321   jresult = (int)result;
32322   return jresult;
32323 }
32324
32325
32326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32327   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32328   int arg2 ;
32329
32330   arg1 = (Dali::WheelEvent *)jarg1;
32331   arg2 = (int)jarg2;
32332   if (arg1) (arg1)->direction = arg2;
32333 }
32334
32335
32336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32337   int jresult ;
32338   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32339   int result;
32340
32341   arg1 = (Dali::WheelEvent *)jarg1;
32342   result = (int) ((arg1)->direction);
32343   jresult = result;
32344   return jresult;
32345 }
32346
32347
32348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32349   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32350   unsigned int arg2 ;
32351
32352   arg1 = (Dali::WheelEvent *)jarg1;
32353   arg2 = (unsigned int)jarg2;
32354   if (arg1) (arg1)->modifiers = arg2;
32355 }
32356
32357
32358 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32359   unsigned int jresult ;
32360   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32361   unsigned int result;
32362
32363   arg1 = (Dali::WheelEvent *)jarg1;
32364   result = (unsigned int) ((arg1)->modifiers);
32365   jresult = result;
32366   return jresult;
32367 }
32368
32369
32370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32371   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32372   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32373
32374   arg1 = (Dali::WheelEvent *)jarg1;
32375   arg2 = (Dali::Vector2 *)jarg2;
32376   if (arg1) (arg1)->point = *arg2;
32377 }
32378
32379
32380 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32381   void * jresult ;
32382   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32383   Dali::Vector2 *result = 0 ;
32384
32385   arg1 = (Dali::WheelEvent *)jarg1;
32386   result = (Dali::Vector2 *)& ((arg1)->point);
32387   jresult = (void *)result;
32388   return jresult;
32389 }
32390
32391
32392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32393   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32394   int arg2 ;
32395
32396   arg1 = (Dali::WheelEvent *)jarg1;
32397   arg2 = (int)jarg2;
32398   if (arg1) (arg1)->z = arg2;
32399 }
32400
32401
32402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32403   int jresult ;
32404   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32405   int result;
32406
32407   arg1 = (Dali::WheelEvent *)jarg1;
32408   result = (int) ((arg1)->z);
32409   jresult = result;
32410   return jresult;
32411 }
32412
32413
32414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32415   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32416   unsigned int arg2 ;
32417
32418   arg1 = (Dali::WheelEvent *)jarg1;
32419   arg2 = (unsigned int)jarg2;
32420   if (arg1) (arg1)->timeStamp = arg2;
32421 }
32422
32423
32424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32425   unsigned int jresult ;
32426   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32427   unsigned int result;
32428
32429   arg1 = (Dali::WheelEvent *)jarg1;
32430   result = (unsigned int) ((arg1)->timeStamp);
32431   jresult = result;
32432   return jresult;
32433 }
32434
32435 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32436   char * jresult ;
32437   Dali::KeyEvent *arg1 = 0 ;
32438   std::string result;
32439
32440   arg1 = (Dali::KeyEvent *)jarg1;
32441   if (!arg1) {
32442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32443     return 0;
32444   }
32445   {
32446     try {
32447       result = arg1->GetDeviceName();
32448     } catch (std::out_of_range& e) {
32449       {
32450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32451       };
32452     } catch (std::exception& e) {
32453       {
32454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32455       };
32456     } catch (Dali::DaliException e) {
32457       {
32458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32459       };
32460     } catch (...) {
32461       {
32462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32463       };
32464     }
32465   }
32466
32467   jresult = SWIG_csharp_string_callback((&result)->c_str());
32468   return jresult;
32469 }
32470
32471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32472   int jresult ;
32473   Dali::KeyEvent *arg1 = 0 ;
32474   Dali::Device::Class::Type result;
32475
32476   arg1 = (Dali::KeyEvent *)jarg1;
32477   if (!arg1) {
32478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32479     return 0;
32480   }
32481   {
32482     try {
32483       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32484     } catch (std::out_of_range& e) {
32485       {
32486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32487       };
32488     } catch (std::exception& e) {
32489       {
32490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32491       };
32492     } catch (Dali::DaliException e) {
32493       {
32494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32495       };
32496     } catch (...) {
32497       {
32498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32499       };
32500     }
32501   }
32502
32503   jresult = (int)result;
32504   return jresult;
32505 }
32506
32507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32508   int jresult ;
32509   Dali::KeyEvent *arg1 = 0 ;
32510   Dali::Device::Subclass::Type result;
32511
32512   arg1 = (Dali::KeyEvent *)jarg1;
32513   if (!arg1) {
32514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32515     return 0;
32516   }
32517   {
32518     try {
32519       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32520     } catch (std::out_of_range& e) {
32521       {
32522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32523       };
32524     } catch (std::exception& e) {
32525       {
32526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32527       };
32528     } catch (Dali::DaliException e) {
32529       {
32530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32531       };
32532     } catch (...) {
32533       {
32534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32535       };
32536     }
32537   }
32538
32539   jresult = (int)result;
32540   return jresult;
32541 }
32542
32543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32544   Dali::Actor arg1 ;
32545   Dali::Actor *argp1 ;
32546
32547   argp1 = (Dali::Actor *)jarg1;
32548   if (!argp1) {
32549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32550     return ;
32551   }
32552   arg1 = *argp1;
32553   {
32554     try {
32555       arg1.Raise();
32556     } catch (std::out_of_range& e) {
32557       {
32558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32559       };
32560     } catch (std::exception& e) {
32561       {
32562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32563       };
32564     } catch (Dali::DaliException e) {
32565       {
32566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32567       };
32568     } catch (...) {
32569       {
32570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32571       };
32572     }
32573   }
32574
32575 }
32576
32577
32578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32579   Dali::Actor arg1 ;
32580   Dali::Actor *argp1 ;
32581
32582   argp1 = (Dali::Actor *)jarg1;
32583   if (!argp1) {
32584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32585     return ;
32586   }
32587   arg1 = *argp1;
32588   {
32589     try {
32590       arg1.Lower();
32591     } catch (std::out_of_range& e) {
32592       {
32593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32594       };
32595     } catch (std::exception& e) {
32596       {
32597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32598       };
32599     } catch (Dali::DaliException e) {
32600       {
32601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32602       };
32603     } catch (...) {
32604       {
32605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32606       };
32607     }
32608   }
32609
32610 }
32611
32612
32613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32614   Dali::Actor arg1 ;
32615   Dali::Actor *argp1 ;
32616
32617   argp1 = (Dali::Actor *)jarg1;
32618   if (!argp1) {
32619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32620     return ;
32621   }
32622   arg1 = *argp1;
32623   {
32624     try {
32625       arg1.RaiseToTop();
32626     } catch (std::out_of_range& e) {
32627       {
32628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32629       };
32630     } catch (std::exception& e) {
32631       {
32632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32633       };
32634     } catch (Dali::DaliException e) {
32635       {
32636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32637       };
32638     } catch (...) {
32639       {
32640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32641       };
32642     }
32643   }
32644
32645 }
32646
32647
32648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32649   Dali::Actor arg1 ;
32650   Dali::Actor *argp1 ;
32651
32652   argp1 = (Dali::Actor *)jarg1;
32653   if (!argp1) {
32654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32655     return ;
32656   }
32657   arg1 = *argp1;
32658   {
32659     try {
32660       arg1.LowerToBottom();
32661     } catch (std::out_of_range& e) {
32662       {
32663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32664       };
32665     } catch (std::exception& e) {
32666       {
32667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32668       };
32669     } catch (Dali::DaliException e) {
32670       {
32671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32672       };
32673     } catch (...) {
32674       {
32675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32676       };
32677     }
32678   }
32679
32680 }
32681
32682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32683   Dali::Actor arg1 ;
32684   Dali::Actor arg2 ;
32685   Dali::Actor *argp1 ;
32686   Dali::Actor *argp2 ;
32687
32688   argp1 = (Dali::Actor *)jarg1;
32689   if (!argp1) {
32690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32691     return ;
32692   }
32693   arg1 = *argp1;
32694   argp2 = (Dali::Actor *)jarg2;
32695   if (!argp2) {
32696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32697     return ;
32698   }
32699   arg2 = *argp2;
32700   {
32701     try {
32702       arg1.RaiseAbove(arg2);
32703     } catch (std::out_of_range& e) {
32704       {
32705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32706       };
32707     } catch (std::exception& e) {
32708       {
32709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32710       };
32711     } catch (Dali::DaliException e) {
32712       {
32713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32714       };
32715     } catch (...) {
32716       {
32717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32718       };
32719     }
32720   }
32721
32722 }
32723
32724
32725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32726   Dali::Actor arg1 ;
32727   Dali::Actor arg2 ;
32728   Dali::Actor *argp1 ;
32729   Dali::Actor *argp2 ;
32730
32731   argp1 = (Dali::Actor *)jarg1;
32732   if (!argp1) {
32733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32734     return ;
32735   }
32736   arg1 = *argp1;
32737   argp2 = (Dali::Actor *)jarg2;
32738   if (!argp2) {
32739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32740     return ;
32741   }
32742   arg2 = *argp2;
32743   {
32744     try {
32745       arg1.LowerBelow(arg2);
32746     } catch (std::out_of_range& e) {
32747       {
32748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32749       };
32750     } catch (std::exception& e) {
32751       {
32752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32753       };
32754     } catch (Dali::DaliException e) {
32755       {
32756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32757       };
32758     } catch (...) {
32759       {
32760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32761       };
32762     }
32763   }
32764
32765 }
32766
32767
32768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32769   void * jresult ;
32770   Dali::Actor arg1 ;
32771   Dali::Actor *argp1 ;
32772   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32773
32774   argp1 = (Dali::Actor *)jarg1;
32775   if (!argp1) {
32776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32777     return 0;
32778   }
32779   arg1 = *argp1;
32780   {
32781     try {
32782       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32783     } catch (std::out_of_range& e) {
32784       {
32785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32786       };
32787     } catch (std::exception& e) {
32788       {
32789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32790       };
32791     } catch (Dali::DaliException e) {
32792       {
32793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32794       };
32795     } catch (...) {
32796       {
32797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32798       };
32799     }
32800   }
32801
32802   jresult = (void *)result;
32803   return jresult;
32804 }
32805
32806
32807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32808   void * jresult ;
32809   Dali::Actor *arg1 ;
32810   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32811
32812   arg1 = (Dali::Actor *)jarg1;
32813   {
32814     try {
32815       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32816     } catch (std::out_of_range& e) {
32817       {
32818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32819       };
32820     } catch (std::exception& e) {
32821       {
32822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32823       };
32824     } catch (Dali::DaliException e) {
32825       {
32826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32827       };
32828     } catch (...) {
32829       {
32830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32831       };
32832     }
32833   }
32834
32835   jresult = (void *)result;
32836   return jresult;
32837 }
32838
32839
32840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32841   int jresult ;
32842   int result;
32843
32844   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32845   jresult = (int)result;
32846   return jresult;
32847 }
32848
32849
32850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32851   int jresult ;
32852   int result;
32853
32854   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32855   jresult = (int)result;
32856   return jresult;
32857 }
32858
32859
32860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32861   int jresult ;
32862   int result;
32863
32864   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32865   jresult = (int)result;
32866   return jresult;
32867 }
32868
32869
32870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32871   int jresult ;
32872   int result;
32873
32874   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32875   jresult = (int)result;
32876   return jresult;
32877 }
32878
32879
32880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32881   int jresult ;
32882   int result;
32883
32884   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32885   jresult = (int)result;
32886   return jresult;
32887 }
32888
32889
32890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32891   int jresult ;
32892   int result;
32893
32894   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32895   jresult = (int)result;
32896   return jresult;
32897 }
32898
32899
32900 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32901   int jresult ;
32902   int result;
32903
32904   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32905   jresult = (int)result;
32906   return jresult;
32907 }
32908
32909
32910 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32911   int jresult ;
32912   int result;
32913
32914   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32915   jresult = (int)result;
32916   return jresult;
32917 }
32918
32919
32920 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32921   int jresult ;
32922   int result;
32923
32924   result = (int)Dali::Actor::Property::SIZE;
32925   jresult = (int)result;
32926   return jresult;
32927 }
32928
32929
32930 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32931   int jresult ;
32932   int result;
32933
32934   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32935   jresult = (int)result;
32936   return jresult;
32937 }
32938
32939
32940 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32941   int jresult ;
32942   int result;
32943
32944   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32945   jresult = (int)result;
32946   return jresult;
32947 }
32948
32949
32950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32951   int jresult ;
32952   int result;
32953
32954   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32955   jresult = (int)result;
32956   return jresult;
32957 }
32958
32959
32960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32961   int jresult ;
32962   int result;
32963
32964   result = (int)Dali::Actor::Property::POSITION;
32965   jresult = (int)result;
32966   return jresult;
32967 }
32968
32969
32970 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32971   int jresult ;
32972   int result;
32973
32974   result = (int)Dali::Actor::Property::POSITION_X;
32975   jresult = (int)result;
32976   return jresult;
32977 }
32978
32979
32980 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32981   int jresult ;
32982   int result;
32983
32984   result = (int)Dali::Actor::Property::POSITION_Y;
32985   jresult = (int)result;
32986   return jresult;
32987 }
32988
32989
32990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32991   int jresult ;
32992   int result;
32993
32994   result = (int)Dali::Actor::Property::POSITION_Z;
32995   jresult = (int)result;
32996   return jresult;
32997 }
32998
32999
33000 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33001   int jresult ;
33002   int result;
33003
33004   result = (int)Dali::Actor::Property::WORLD_POSITION;
33005   jresult = (int)result;
33006   return jresult;
33007 }
33008
33009
33010 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33011   int jresult ;
33012   int result;
33013
33014   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33015   jresult = (int)result;
33016   return jresult;
33017 }
33018
33019
33020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33021   int jresult ;
33022   int result;
33023
33024   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33025   jresult = (int)result;
33026   return jresult;
33027 }
33028
33029
33030 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33031   int jresult ;
33032   int result;
33033
33034   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33035   jresult = (int)result;
33036   return jresult;
33037 }
33038
33039
33040 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33041   int jresult ;
33042   int result;
33043
33044   result = (int)Dali::Actor::Property::ORIENTATION;
33045   jresult = (int)result;
33046   return jresult;
33047 }
33048
33049
33050 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33051   int jresult ;
33052   int result;
33053
33054   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33055   jresult = (int)result;
33056   return jresult;
33057 }
33058
33059
33060 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33061   int jresult ;
33062   int result;
33063
33064   result = (int)Dali::Actor::Property::SCALE;
33065   jresult = (int)result;
33066   return jresult;
33067 }
33068
33069
33070 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33071   int jresult ;
33072   int result;
33073
33074   result = (int)Dali::Actor::Property::SCALE_X;
33075   jresult = (int)result;
33076   return jresult;
33077 }
33078
33079
33080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33081   int jresult ;
33082   int result;
33083
33084   result = (int)Dali::Actor::Property::SCALE_Y;
33085   jresult = (int)result;
33086   return jresult;
33087 }
33088
33089
33090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33091   int jresult ;
33092   int result;
33093
33094   result = (int)Dali::Actor::Property::SCALE_Z;
33095   jresult = (int)result;
33096   return jresult;
33097 }
33098
33099
33100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33101   int jresult ;
33102   int result;
33103
33104   result = (int)Dali::Actor::Property::WORLD_SCALE;
33105   jresult = (int)result;
33106   return jresult;
33107 }
33108
33109
33110 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33111   int jresult ;
33112   int result;
33113
33114   result = (int)Dali::Actor::Property::VISIBLE;
33115   jresult = (int)result;
33116   return jresult;
33117 }
33118
33119
33120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33121   int jresult ;
33122   int result;
33123
33124   result = (int)Dali::Actor::Property::COLOR;
33125   jresult = (int)result;
33126   return jresult;
33127 }
33128
33129
33130 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33131   int jresult ;
33132   int result;
33133
33134   result = (int)Dali::Actor::Property::COLOR_RED;
33135   jresult = (int)result;
33136   return jresult;
33137 }
33138
33139
33140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33141   int jresult ;
33142   int result;
33143
33144   result = (int)Dali::Actor::Property::COLOR_GREEN;
33145   jresult = (int)result;
33146   return jresult;
33147 }
33148
33149
33150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33151   int jresult ;
33152   int result;
33153
33154   result = (int)Dali::Actor::Property::COLOR_BLUE;
33155   jresult = (int)result;
33156   return jresult;
33157 }
33158
33159
33160 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33161   int jresult ;
33162   int result;
33163
33164   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33165   jresult = (int)result;
33166   return jresult;
33167 }
33168
33169
33170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33171   int jresult ;
33172   int result;
33173
33174   result = (int)Dali::Actor::Property::WORLD_COLOR;
33175   jresult = (int)result;
33176   return jresult;
33177 }
33178
33179
33180 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33181   int jresult ;
33182   int result;
33183
33184   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33185   jresult = (int)result;
33186   return jresult;
33187 }
33188
33189
33190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33191   int jresult ;
33192   int result;
33193
33194   result = (int)Dali::Actor::Property::NAME;
33195   jresult = (int)result;
33196   return jresult;
33197 }
33198
33199
33200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33201   int jresult ;
33202   int result;
33203
33204   result = (int)Dali::Actor::Property::SENSITIVE;
33205   jresult = (int)result;
33206   return jresult;
33207 }
33208
33209
33210 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33211   int jresult ;
33212   int result;
33213
33214   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33215   jresult = (int)result;
33216   return jresult;
33217 }
33218
33219
33220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33221   int jresult ;
33222   int result;
33223
33224   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33225   jresult = (int)result;
33226   return jresult;
33227 }
33228
33229
33230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33231   int jresult ;
33232   int result;
33233
33234   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33235   jresult = (int)result;
33236   return jresult;
33237 }
33238
33239
33240 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33241   int jresult ;
33242   int result;
33243
33244   result = (int)Dali::Actor::Property::COLOR_MODE;
33245   jresult = (int)result;
33246   return jresult;
33247 }
33248
33249
33250 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33251   int jresult ;
33252   int result;
33253
33254   result = (int)Dali::Actor::Property::DRAW_MODE;
33255   jresult = (int)result;
33256   return jresult;
33257 }
33258
33259
33260 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33261   int jresult ;
33262   int result;
33263
33264   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33265   jresult = (int)result;
33266   return jresult;
33267 }
33268
33269
33270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33271   int jresult ;
33272   int result;
33273
33274   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33275   jresult = (int)result;
33276   return jresult;
33277 }
33278
33279
33280 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33281   int jresult ;
33282   int result;
33283
33284   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33285   jresult = (int)result;
33286   return jresult;
33287 }
33288
33289
33290 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33291   int jresult ;
33292   int result;
33293
33294   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33295   jresult = (int)result;
33296   return jresult;
33297 }
33298
33299
33300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33301   int jresult ;
33302   int result;
33303
33304   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33305   jresult = (int)result;
33306   return jresult;
33307 }
33308
33309
33310 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33311   int jresult ;
33312   int result;
33313
33314   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33315   jresult = (int)result;
33316   return jresult;
33317 }
33318
33319
33320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33321   int jresult ;
33322   int result;
33323
33324   result = (int)Dali::Actor::Property::PADDING;
33325   jresult = (int)result;
33326   return jresult;
33327 }
33328
33329
33330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33331   int jresult ;
33332   int result;
33333
33334   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33335   jresult = (int)result;
33336   return jresult;
33337 }
33338
33339
33340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33341   int jresult ;
33342   int result;
33343
33344   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33345   jresult = (int)result;
33346   return jresult;
33347 }
33348
33349
33350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33351   int jresult ;
33352   int result;
33353
33354   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33355   jresult = (int)result;
33356   return jresult;
33357 }
33358
33359
33360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33361   int jresult ;
33362   int result;
33363
33364   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33365   jresult = (int)result;
33366   return jresult;
33367 }
33368
33369
33370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33371   void * jresult ;
33372   Dali::Actor::Property *result = 0 ;
33373
33374   {
33375     try {
33376       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33377     } catch (std::out_of_range& e) {
33378       {
33379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33380       };
33381     } catch (std::exception& e) {
33382       {
33383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33384       };
33385     } catch (Dali::DaliException e) {
33386       {
33387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33388       };
33389     } catch (...) {
33390       {
33391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33392       };
33393     }
33394   }
33395
33396   jresult = (void *)result;
33397   return jresult;
33398 }
33399
33400
33401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33402   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33403
33404   arg1 = (Dali::Actor::Property *)jarg1;
33405   {
33406     try {
33407       delete arg1;
33408     } catch (std::out_of_range& e) {
33409       {
33410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33411       };
33412     } catch (std::exception& e) {
33413       {
33414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33415       };
33416     } catch (Dali::DaliException e) {
33417       {
33418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33419       };
33420     } catch (...) {
33421       {
33422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33423       };
33424     }
33425   }
33426
33427 }
33428
33429
33430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33431   void * jresult ;
33432   Dali::Actor *result = 0 ;
33433
33434   {
33435     try {
33436       result = (Dali::Actor *)new Dali::Actor();
33437     } catch (std::out_of_range& e) {
33438       {
33439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33440       };
33441     } catch (std::exception& e) {
33442       {
33443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33444       };
33445     } catch (Dali::DaliException e) {
33446       {
33447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33448       };
33449     } catch (...) {
33450       {
33451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33452       };
33453     }
33454   }
33455
33456   jresult = (void *)result;
33457   return jresult;
33458 }
33459
33460
33461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33462   void * jresult ;
33463   Dali::Actor result;
33464
33465   {
33466     try {
33467       result = Dali::Actor::New();
33468     } catch (std::out_of_range& e) {
33469       {
33470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33471       };
33472     } catch (std::exception& e) {
33473       {
33474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33475       };
33476     } catch (Dali::DaliException e) {
33477       {
33478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33479       };
33480     } catch (...) {
33481       {
33482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33483       };
33484     }
33485   }
33486
33487   jresult = new Dali::Actor((const Dali::Actor &)result);
33488   return jresult;
33489 }
33490
33491
33492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33493   void * jresult ;
33494   Dali::BaseHandle arg1 ;
33495   Dali::BaseHandle *argp1 ;
33496   Dali::Actor result;
33497
33498   argp1 = (Dali::BaseHandle *)jarg1;
33499   if (!argp1) {
33500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33501     return 0;
33502   }
33503   arg1 = *argp1;
33504   {
33505     try {
33506       result = Dali::Actor::DownCast(arg1);
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_delete_Actor(void * jarg1) {
33532   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33533
33534   arg1 = (Dali::Actor *)jarg1;
33535   {
33536     try {
33537       delete arg1;
33538     } catch (std::out_of_range& e) {
33539       {
33540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33541       };
33542     } catch (std::exception& e) {
33543       {
33544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33545       };
33546     } catch (Dali::DaliException e) {
33547       {
33548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33549       };
33550     } catch (...) {
33551       {
33552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33553       };
33554     }
33555   }
33556
33557 }
33558
33559
33560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33561   void * jresult ;
33562   Dali::Actor *arg1 = 0 ;
33563   Dali::Actor *result = 0 ;
33564
33565   arg1 = (Dali::Actor *)jarg1;
33566   if (!arg1) {
33567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33568     return 0;
33569   }
33570   {
33571     try {
33572       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33573     } catch (std::out_of_range& e) {
33574       {
33575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33576       };
33577     } catch (std::exception& e) {
33578       {
33579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33580       };
33581     } catch (Dali::DaliException e) {
33582       {
33583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33584       };
33585     } catch (...) {
33586       {
33587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33588       };
33589     }
33590   }
33591
33592   jresult = (void *)result;
33593   return jresult;
33594 }
33595
33596
33597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33598   void * jresult ;
33599   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33600   Dali::Actor *arg2 = 0 ;
33601   Dali::Actor *result = 0 ;
33602
33603   arg1 = (Dali::Actor *)jarg1;
33604   arg2 = (Dali::Actor *)jarg2;
33605   if (!arg2) {
33606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33607     return 0;
33608   }
33609   {
33610     try {
33611       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
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 char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33637   char * jresult ;
33638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33639   std::string *result = 0 ;
33640
33641   arg1 = (Dali::Actor *)jarg1;
33642   {
33643     try {
33644       result = (std::string *) &((Dali::Actor const *)arg1)->GetName();
33645     } catch (std::out_of_range& e) {
33646       {
33647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33648       };
33649     } catch (std::exception& e) {
33650       {
33651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33652       };
33653     } catch (Dali::DaliException e) {
33654       {
33655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33656       };
33657     } catch (...) {
33658       {
33659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33660       };
33661     }
33662   }
33663
33664   jresult = SWIG_csharp_string_callback(result->c_str());
33665   return jresult;
33666 }
33667
33668
33669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33671   std::string *arg2 = 0 ;
33672
33673   arg1 = (Dali::Actor *)jarg1;
33674   if (!jarg2) {
33675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33676     return ;
33677   }
33678   std::string arg2_str(jarg2);
33679   arg2 = &arg2_str;
33680   {
33681     try {
33682       (arg1)->SetName((std::string const &)*arg2);
33683     } catch (std::out_of_range& e) {
33684       {
33685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33686       };
33687     } catch (std::exception& e) {
33688       {
33689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33690       };
33691     } catch (Dali::DaliException e) {
33692       {
33693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33694       };
33695     } catch (...) {
33696       {
33697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33698       };
33699     }
33700   }
33701
33702
33703   //argout typemap for const std::string&
33704
33705 }
33706
33707
33708 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33709   unsigned int jresult ;
33710   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33711   unsigned int result;
33712
33713   arg1 = (Dali::Actor *)jarg1;
33714   {
33715     try {
33716       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33717     } catch (std::out_of_range& e) {
33718       {
33719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33720       };
33721     } catch (std::exception& e) {
33722       {
33723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33724       };
33725     } catch (Dali::DaliException e) {
33726       {
33727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33728       };
33729     } catch (...) {
33730       {
33731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33732       };
33733     }
33734   }
33735
33736   jresult = result;
33737   return jresult;
33738 }
33739
33740
33741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33742   unsigned int jresult ;
33743   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33744   bool result;
33745
33746   arg1 = (Dali::Actor *)jarg1;
33747   {
33748     try {
33749       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33750     } catch (std::out_of_range& e) {
33751       {
33752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33753       };
33754     } catch (std::exception& e) {
33755       {
33756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33757       };
33758     } catch (Dali::DaliException e) {
33759       {
33760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33761       };
33762     } catch (...) {
33763       {
33764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33765       };
33766     }
33767   }
33768
33769   jresult = result;
33770   return jresult;
33771 }
33772
33773
33774 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33775   unsigned int jresult ;
33776   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33777   bool result;
33778
33779   arg1 = (Dali::Actor *)jarg1;
33780   {
33781     try {
33782       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33783     } catch (std::out_of_range& e) {
33784       {
33785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33786       };
33787     } catch (std::exception& e) {
33788       {
33789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33790       };
33791     } catch (Dali::DaliException e) {
33792       {
33793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33794       };
33795     } catch (...) {
33796       {
33797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33798       };
33799     }
33800   }
33801
33802   jresult = result;
33803   return jresult;
33804 }
33805
33806
33807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33808   unsigned int jresult ;
33809   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33810   bool result;
33811
33812   arg1 = (Dali::Actor *)jarg1;
33813   {
33814     try {
33815       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33816     } catch (std::out_of_range& e) {
33817       {
33818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33819       };
33820     } catch (std::exception& e) {
33821       {
33822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33823       };
33824     } catch (Dali::DaliException e) {
33825       {
33826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33827       };
33828     } catch (...) {
33829       {
33830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33831       };
33832     }
33833   }
33834
33835   jresult = result;
33836   return jresult;
33837 }
33838
33839
33840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33841   void * jresult ;
33842   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33843   Dali::Layer result;
33844
33845   arg1 = (Dali::Actor *)jarg1;
33846   {
33847     try {
33848       result = (arg1)->GetLayer();
33849     } catch (std::out_of_range& e) {
33850       {
33851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33852       };
33853     } catch (std::exception& e) {
33854       {
33855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33856       };
33857     } catch (Dali::DaliException e) {
33858       {
33859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33860       };
33861     } catch (...) {
33862       {
33863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33864       };
33865     }
33866   }
33867
33868   jresult = new Dali::Layer((const Dali::Layer &)result);
33869   return jresult;
33870 }
33871
33872
33873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33874   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33875   Dali::Actor arg2 ;
33876   Dali::Actor *argp2 ;
33877
33878   arg1 = (Dali::Actor *)jarg1;
33879   argp2 = (Dali::Actor *)jarg2;
33880   if (!argp2) {
33881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33882     return ;
33883   }
33884   arg2 = *argp2;
33885   {
33886     try {
33887       (arg1)->Add(arg2);
33888     } catch (std::out_of_range& e) {
33889       {
33890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33891       };
33892     } catch (std::exception& e) {
33893       {
33894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33895       };
33896     } catch (Dali::DaliException e) {
33897       {
33898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33899       };
33900     } catch (...) {
33901       {
33902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33903       };
33904     }
33905   }
33906
33907 }
33908
33909
33910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33912   Dali::Actor arg2 ;
33913   Dali::Actor *argp2 ;
33914
33915   arg1 = (Dali::Actor *)jarg1;
33916   argp2 = (Dali::Actor *)jarg2;
33917   if (!argp2) {
33918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33919     return ;
33920   }
33921   arg2 = *argp2;
33922   {
33923     try {
33924       (arg1)->Remove(arg2);
33925     } catch (std::out_of_range& e) {
33926       {
33927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33928       };
33929     } catch (std::exception& e) {
33930       {
33931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33932       };
33933     } catch (Dali::DaliException e) {
33934       {
33935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33936       };
33937     } catch (...) {
33938       {
33939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33940       };
33941     }
33942   }
33943
33944 }
33945
33946
33947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33948   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33949
33950   arg1 = (Dali::Actor *)jarg1;
33951   {
33952     try {
33953       (arg1)->Unparent();
33954     } catch (std::out_of_range& e) {
33955       {
33956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33957       };
33958     } catch (std::exception& e) {
33959       {
33960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33961       };
33962     } catch (Dali::DaliException e) {
33963       {
33964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33965       };
33966     } catch (...) {
33967       {
33968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33969       };
33970     }
33971   }
33972
33973 }
33974
33975
33976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33977   unsigned int jresult ;
33978   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33979   unsigned int result;
33980
33981   arg1 = (Dali::Actor *)jarg1;
33982   {
33983     try {
33984       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33985     } catch (std::out_of_range& e) {
33986       {
33987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33988       };
33989     } catch (std::exception& e) {
33990       {
33991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33992       };
33993     } catch (Dali::DaliException e) {
33994       {
33995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33996       };
33997     } catch (...) {
33998       {
33999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34000       };
34001     }
34002   }
34003
34004   jresult = result;
34005   return jresult;
34006 }
34007
34008
34009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34010   void * jresult ;
34011   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34012   unsigned int arg2 ;
34013   Dali::Actor result;
34014
34015   arg1 = (Dali::Actor *)jarg1;
34016   arg2 = (unsigned int)jarg2;
34017   {
34018     try {
34019       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34020     } catch (std::out_of_range& e) {
34021       {
34022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34023       };
34024     } catch (std::exception& e) {
34025       {
34026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34027       };
34028     } catch (Dali::DaliException e) {
34029       {
34030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34031       };
34032     } catch (...) {
34033       {
34034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34035       };
34036     }
34037   }
34038
34039   jresult = new Dali::Actor((const Dali::Actor &)result);
34040   return jresult;
34041 }
34042
34043
34044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34045   void * jresult ;
34046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34047   std::string *arg2 = 0 ;
34048   Dali::Actor result;
34049
34050   arg1 = (Dali::Actor *)jarg1;
34051   if (!jarg2) {
34052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34053     return 0;
34054   }
34055   std::string arg2_str(jarg2);
34056   arg2 = &arg2_str;
34057   {
34058     try {
34059       result = (arg1)->FindChildByName((std::string const &)*arg2);
34060     } catch (std::out_of_range& e) {
34061       {
34062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34063       };
34064     } catch (std::exception& e) {
34065       {
34066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34067       };
34068     } catch (Dali::DaliException e) {
34069       {
34070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34071       };
34072     } catch (...) {
34073       {
34074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34075       };
34076     }
34077   }
34078
34079   jresult = new Dali::Actor((const Dali::Actor &)result);
34080
34081   //argout typemap for const std::string&
34082
34083   return jresult;
34084 }
34085
34086
34087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34088   void * jresult ;
34089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34090   unsigned int arg2 ;
34091   Dali::Actor result;
34092
34093   arg1 = (Dali::Actor *)jarg1;
34094   arg2 = (unsigned int)jarg2;
34095   {
34096     try {
34097       result = (arg1)->FindChildById(arg2);
34098     } catch (std::out_of_range& e) {
34099       {
34100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34101       };
34102     } catch (std::exception& e) {
34103       {
34104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34105       };
34106     } catch (Dali::DaliException e) {
34107       {
34108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34109       };
34110     } catch (...) {
34111       {
34112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34113       };
34114     }
34115   }
34116
34117   jresult = new Dali::Actor((const Dali::Actor &)result);
34118   return jresult;
34119 }
34120
34121
34122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34123   void * jresult ;
34124   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34125   Dali::Actor result;
34126
34127   arg1 = (Dali::Actor *)jarg1;
34128   {
34129     try {
34130       result = ((Dali::Actor const *)arg1)->GetParent();
34131     } catch (std::out_of_range& e) {
34132       {
34133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34134       };
34135     } catch (std::exception& e) {
34136       {
34137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34138       };
34139     } catch (Dali::DaliException e) {
34140       {
34141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34142       };
34143     } catch (...) {
34144       {
34145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34146       };
34147     }
34148   }
34149
34150   jresult = new Dali::Actor((const Dali::Actor &)result);
34151   return jresult;
34152 }
34153
34154
34155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34156   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34157   Dali::Vector3 *arg2 = 0 ;
34158
34159   arg1 = (Dali::Actor *)jarg1;
34160   arg2 = (Dali::Vector3 *)jarg2;
34161   if (!arg2) {
34162     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34163     return ;
34164   }
34165   {
34166     try {
34167       (arg1)->SetParentOrigin((Dali::Vector3 const &)*arg2);
34168     } catch (std::out_of_range& e) {
34169       {
34170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34171       };
34172     } catch (std::exception& e) {
34173       {
34174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34175       };
34176     } catch (Dali::DaliException e) {
34177       {
34178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34179       };
34180     } catch (...) {
34181       {
34182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34183       };
34184     }
34185   }
34186
34187 }
34188
34189
34190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34191   void * jresult ;
34192   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34193   Dali::Vector3 result;
34194
34195   arg1 = (Dali::Actor *)jarg1;
34196   {
34197     try {
34198       result = ((Dali::Actor const *)arg1)->GetCurrentParentOrigin();
34199     } catch (std::out_of_range& e) {
34200       {
34201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34202       };
34203     } catch (std::exception& e) {
34204       {
34205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34206       };
34207     } catch (Dali::DaliException e) {
34208       {
34209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34210       };
34211     } catch (...) {
34212       {
34213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34214       };
34215     }
34216   }
34217
34218   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34219   return jresult;
34220 }
34221
34222
34223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34224   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34225   Dali::Vector3 *arg2 = 0 ;
34226
34227   arg1 = (Dali::Actor *)jarg1;
34228   arg2 = (Dali::Vector3 *)jarg2;
34229   if (!arg2) {
34230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34231     return ;
34232   }
34233   {
34234     try {
34235       (arg1)->SetAnchorPoint((Dali::Vector3 const &)*arg2);
34236     } catch (std::out_of_range& e) {
34237       {
34238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34239       };
34240     } catch (std::exception& e) {
34241       {
34242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34243       };
34244     } catch (Dali::DaliException e) {
34245       {
34246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34247       };
34248     } catch (...) {
34249       {
34250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34251       };
34252     }
34253   }
34254
34255 }
34256
34257
34258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34259   void * jresult ;
34260   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34261   Dali::Vector3 result;
34262
34263   arg1 = (Dali::Actor *)jarg1;
34264   {
34265     try {
34266       result = ((Dali::Actor const *)arg1)->GetCurrentAnchorPoint();
34267     } catch (std::out_of_range& e) {
34268       {
34269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34270       };
34271     } catch (std::exception& e) {
34272       {
34273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34274       };
34275     } catch (Dali::DaliException e) {
34276       {
34277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34278       };
34279     } catch (...) {
34280       {
34281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34282       };
34283     }
34284   }
34285
34286   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34287   return jresult;
34288 }
34289
34290
34291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34292   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34293   float arg2 ;
34294   float arg3 ;
34295
34296   arg1 = (Dali::Actor *)jarg1;
34297   arg2 = (float)jarg2;
34298   arg3 = (float)jarg3;
34299   {
34300     try {
34301       (arg1)->SetSize(arg2,arg3);
34302     } catch (std::out_of_range& e) {
34303       {
34304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34305       };
34306     } catch (std::exception& e) {
34307       {
34308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34309       };
34310     } catch (Dali::DaliException e) {
34311       {
34312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34313       };
34314     } catch (...) {
34315       {
34316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34317       };
34318     }
34319   }
34320
34321 }
34322
34323
34324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34326   float arg2 ;
34327   float arg3 ;
34328   float arg4 ;
34329
34330   arg1 = (Dali::Actor *)jarg1;
34331   arg2 = (float)jarg2;
34332   arg3 = (float)jarg3;
34333   arg4 = (float)jarg4;
34334   {
34335     try {
34336       (arg1)->SetSize(arg2,arg3,arg4);
34337     } catch (std::out_of_range& e) {
34338       {
34339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34340       };
34341     } catch (std::exception& e) {
34342       {
34343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34344       };
34345     } catch (Dali::DaliException e) {
34346       {
34347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34348       };
34349     } catch (...) {
34350       {
34351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34352       };
34353     }
34354   }
34355
34356 }
34357
34358
34359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34361   Dali::Vector2 *arg2 = 0 ;
34362
34363   arg1 = (Dali::Actor *)jarg1;
34364   arg2 = (Dali::Vector2 *)jarg2;
34365   if (!arg2) {
34366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34367     return ;
34368   }
34369   {
34370     try {
34371       (arg1)->SetSize((Dali::Vector2 const &)*arg2);
34372     } catch (std::out_of_range& e) {
34373       {
34374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34375       };
34376     } catch (std::exception& e) {
34377       {
34378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34379       };
34380     } catch (Dali::DaliException e) {
34381       {
34382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34383       };
34384     } catch (...) {
34385       {
34386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34387       };
34388     }
34389   }
34390
34391 }
34392
34393
34394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34395   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34396   Dali::Vector3 *arg2 = 0 ;
34397
34398   arg1 = (Dali::Actor *)jarg1;
34399   arg2 = (Dali::Vector3 *)jarg2;
34400   if (!arg2) {
34401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34402     return ;
34403   }
34404   {
34405     try {
34406       (arg1)->SetSize((Dali::Vector3 const &)*arg2);
34407     } catch (std::out_of_range& e) {
34408       {
34409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34410       };
34411     } catch (std::exception& e) {
34412       {
34413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34414       };
34415     } catch (Dali::DaliException e) {
34416       {
34417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34418       };
34419     } catch (...) {
34420       {
34421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34422       };
34423     }
34424   }
34425
34426 }
34427
34428
34429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34430   void * jresult ;
34431   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34432   Dali::Vector3 result;
34433
34434   arg1 = (Dali::Actor *)jarg1;
34435   {
34436     try {
34437       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34438     } catch (std::out_of_range& e) {
34439       {
34440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34441       };
34442     } catch (std::exception& e) {
34443       {
34444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34445       };
34446     } catch (Dali::DaliException e) {
34447       {
34448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34449       };
34450     } catch (...) {
34451       {
34452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34453       };
34454     }
34455   }
34456
34457   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34458   return jresult;
34459 }
34460
34461
34462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34463   void * jresult ;
34464   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34465   Dali::Vector3 result;
34466
34467   arg1 = (Dali::Actor *)jarg1;
34468   {
34469     try {
34470       result = ((Dali::Actor const *)arg1)->GetCurrentSize();
34471     } catch (std::out_of_range& e) {
34472       {
34473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34474       };
34475     } catch (std::exception& e) {
34476       {
34477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34478       };
34479     } catch (Dali::DaliException e) {
34480       {
34481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34482       };
34483     } catch (...) {
34484       {
34485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34486       };
34487     }
34488   }
34489
34490   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34491   return jresult;
34492 }
34493
34494
34495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34496   void * jresult ;
34497   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34498   Dali::Vector3 result;
34499
34500   arg1 = (Dali::Actor *)jarg1;
34501   {
34502     try {
34503       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34504     } catch (std::out_of_range& e) {
34505       {
34506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34507       };
34508     } catch (std::exception& e) {
34509       {
34510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34511       };
34512     } catch (Dali::DaliException e) {
34513       {
34514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34515       };
34516     } catch (...) {
34517       {
34518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34519       };
34520     }
34521   }
34522
34523   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34524   return jresult;
34525 }
34526
34527
34528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34529   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34530   float arg2 ;
34531   float arg3 ;
34532
34533   arg1 = (Dali::Actor *)jarg1;
34534   arg2 = (float)jarg2;
34535   arg3 = (float)jarg3;
34536   {
34537     try {
34538       (arg1)->SetPosition(arg2,arg3);
34539     } catch (std::out_of_range& e) {
34540       {
34541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34542       };
34543     } catch (std::exception& e) {
34544       {
34545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34546       };
34547     } catch (Dali::DaliException e) {
34548       {
34549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34550       };
34551     } catch (...) {
34552       {
34553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34554       };
34555     }
34556   }
34557
34558 }
34559
34560
34561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34562   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34563   float arg2 ;
34564   float arg3 ;
34565   float arg4 ;
34566
34567   arg1 = (Dali::Actor *)jarg1;
34568   arg2 = (float)jarg2;
34569   arg3 = (float)jarg3;
34570   arg4 = (float)jarg4;
34571   {
34572     try {
34573       (arg1)->SetPosition(arg2,arg3,arg4);
34574     } catch (std::out_of_range& e) {
34575       {
34576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34577       };
34578     } catch (std::exception& e) {
34579       {
34580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34581       };
34582     } catch (Dali::DaliException e) {
34583       {
34584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34585       };
34586     } catch (...) {
34587       {
34588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34589       };
34590     }
34591   }
34592
34593 }
34594
34595
34596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34597   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34598   Dali::Vector3 *arg2 = 0 ;
34599
34600   arg1 = (Dali::Actor *)jarg1;
34601   arg2 = (Dali::Vector3 *)jarg2;
34602   if (!arg2) {
34603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34604     return ;
34605   }
34606   {
34607     try {
34608       (arg1)->SetPosition((Dali::Vector3 const &)*arg2);
34609     } catch (std::out_of_range& e) {
34610       {
34611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34612       };
34613     } catch (std::exception& e) {
34614       {
34615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34616       };
34617     } catch (Dali::DaliException e) {
34618       {
34619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34620       };
34621     } catch (...) {
34622       {
34623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34624       };
34625     }
34626   }
34627
34628 }
34629
34630
34631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34633   float arg2 ;
34634
34635   arg1 = (Dali::Actor *)jarg1;
34636   arg2 = (float)jarg2;
34637   {
34638     try {
34639       (arg1)->SetX(arg2);
34640     } catch (std::out_of_range& e) {
34641       {
34642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34643       };
34644     } catch (std::exception& e) {
34645       {
34646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34647       };
34648     } catch (Dali::DaliException e) {
34649       {
34650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34651       };
34652     } catch (...) {
34653       {
34654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34655       };
34656     }
34657   }
34658
34659 }
34660
34661
34662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34663   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34664   float arg2 ;
34665
34666   arg1 = (Dali::Actor *)jarg1;
34667   arg2 = (float)jarg2;
34668   {
34669     try {
34670       (arg1)->SetY(arg2);
34671     } catch (std::out_of_range& e) {
34672       {
34673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34674       };
34675     } catch (std::exception& e) {
34676       {
34677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34678       };
34679     } catch (Dali::DaliException e) {
34680       {
34681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34682       };
34683     } catch (...) {
34684       {
34685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34686       };
34687     }
34688   }
34689
34690 }
34691
34692
34693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34694   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34695   float arg2 ;
34696
34697   arg1 = (Dali::Actor *)jarg1;
34698   arg2 = (float)jarg2;
34699   {
34700     try {
34701       (arg1)->SetZ(arg2);
34702     } catch (std::out_of_range& e) {
34703       {
34704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34705       };
34706     } catch (std::exception& e) {
34707       {
34708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34709       };
34710     } catch (Dali::DaliException e) {
34711       {
34712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34713       };
34714     } catch (...) {
34715       {
34716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34717       };
34718     }
34719   }
34720
34721 }
34722
34723
34724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34725   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34726   Dali::Vector3 *arg2 = 0 ;
34727
34728   arg1 = (Dali::Actor *)jarg1;
34729   arg2 = (Dali::Vector3 *)jarg2;
34730   if (!arg2) {
34731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34732     return ;
34733   }
34734   {
34735     try {
34736       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34737     } catch (std::out_of_range& e) {
34738       {
34739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34740       };
34741     } catch (std::exception& e) {
34742       {
34743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34744       };
34745     } catch (Dali::DaliException e) {
34746       {
34747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34748       };
34749     } catch (...) {
34750       {
34751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34752       };
34753     }
34754   }
34755
34756 }
34757
34758
34759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34760   void * jresult ;
34761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34762   Dali::Vector3 result;
34763
34764   arg1 = (Dali::Actor *)jarg1;
34765   {
34766     try {
34767       result = ((Dali::Actor const *)arg1)->GetCurrentPosition();
34768     } catch (std::out_of_range& e) {
34769       {
34770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34771       };
34772     } catch (std::exception& e) {
34773       {
34774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34775       };
34776     } catch (Dali::DaliException e) {
34777       {
34778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34779       };
34780     } catch (...) {
34781       {
34782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34783       };
34784     }
34785   }
34786
34787   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34788   return jresult;
34789 }
34790
34791
34792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34793   void * jresult ;
34794   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34795   Dali::Vector3 result;
34796
34797   arg1 = (Dali::Actor *)jarg1;
34798   {
34799     try {
34800       result = ((Dali::Actor const *)arg1)->GetCurrentWorldPosition();
34801     } catch (std::out_of_range& e) {
34802       {
34803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34804       };
34805     } catch (std::exception& e) {
34806       {
34807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34808       };
34809     } catch (Dali::DaliException e) {
34810       {
34811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34812       };
34813     } catch (...) {
34814       {
34815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34816       };
34817     }
34818   }
34819
34820   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34821   return jresult;
34822 }
34823
34824
34825 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34826   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34827   bool arg2 ;
34828
34829   arg1 = (Dali::Actor *)jarg1;
34830   arg2 = jarg2 ? true : false;
34831   {
34832     try {
34833       (arg1)->SetInheritPosition(arg2);
34834     } catch (std::out_of_range& e) {
34835       {
34836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34837       };
34838     } catch (std::exception& e) {
34839       {
34840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34841       };
34842     } catch (Dali::DaliException e) {
34843       {
34844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34845       };
34846     } catch (...) {
34847       {
34848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34849       };
34850     }
34851   }
34852
34853 }
34854
34855
34856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34857   unsigned int jresult ;
34858   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34859   bool result;
34860
34861   arg1 = (Dali::Actor *)jarg1;
34862   {
34863     try {
34864       result = (bool)((Dali::Actor const *)arg1)->IsPositionInherited();
34865     } catch (std::out_of_range& e) {
34866       {
34867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34868       };
34869     } catch (std::exception& e) {
34870       {
34871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34872       };
34873     } catch (Dali::DaliException e) {
34874       {
34875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34876       };
34877     } catch (...) {
34878       {
34879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34880       };
34881     }
34882   }
34883
34884   jresult = result;
34885   return jresult;
34886 }
34887
34888
34889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34890   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34891   Dali::Degree *arg2 = 0 ;
34892   Dali::Vector3 *arg3 = 0 ;
34893
34894   arg1 = (Dali::Actor *)jarg1;
34895   arg2 = (Dali::Degree *)jarg2;
34896   if (!arg2) {
34897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34898     return ;
34899   }
34900   arg3 = (Dali::Vector3 *)jarg3;
34901   if (!arg3) {
34902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34903     return ;
34904   }
34905   {
34906     try {
34907       (arg1)->SetOrientation((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34908     } catch (std::out_of_range& e) {
34909       {
34910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34911       };
34912     } catch (std::exception& e) {
34913       {
34914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34915       };
34916     } catch (Dali::DaliException e) {
34917       {
34918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34919       };
34920     } catch (...) {
34921       {
34922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34923       };
34924     }
34925   }
34926
34927 }
34928
34929
34930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34931   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34932   Dali::Radian *arg2 = 0 ;
34933   Dali::Vector3 *arg3 = 0 ;
34934
34935   arg1 = (Dali::Actor *)jarg1;
34936   arg2 = (Dali::Radian *)jarg2;
34937   if (!arg2) {
34938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34939     return ;
34940   }
34941   arg3 = (Dali::Vector3 *)jarg3;
34942   if (!arg3) {
34943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34944     return ;
34945   }
34946   {
34947     try {
34948       (arg1)->SetOrientation((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34949     } catch (std::out_of_range& e) {
34950       {
34951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34952       };
34953     } catch (std::exception& e) {
34954       {
34955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34956       };
34957     } catch (Dali::DaliException e) {
34958       {
34959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34960       };
34961     } catch (...) {
34962       {
34963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34964       };
34965     }
34966   }
34967
34968 }
34969
34970
34971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34972   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34973   Dali::Quaternion *arg2 = 0 ;
34974
34975   arg1 = (Dali::Actor *)jarg1;
34976   arg2 = (Dali::Quaternion *)jarg2;
34977   if (!arg2) {
34978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34979     return ;
34980   }
34981   {
34982     try {
34983       (arg1)->SetOrientation((Dali::Quaternion const &)*arg2);
34984     } catch (std::out_of_range& e) {
34985       {
34986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34987       };
34988     } catch (std::exception& e) {
34989       {
34990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34991       };
34992     } catch (Dali::DaliException e) {
34993       {
34994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34995       };
34996     } catch (...) {
34997       {
34998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34999       };
35000     }
35001   }
35002
35003 }
35004
35005
35006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35007   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35008   Dali::Degree *arg2 = 0 ;
35009   Dali::Vector3 *arg3 = 0 ;
35010
35011   arg1 = (Dali::Actor *)jarg1;
35012   arg2 = (Dali::Degree *)jarg2;
35013   if (!arg2) {
35014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35015     return ;
35016   }
35017   arg3 = (Dali::Vector3 *)jarg3;
35018   if (!arg3) {
35019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35020     return ;
35021   }
35022   {
35023     try {
35024       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35025     } catch (std::out_of_range& e) {
35026       {
35027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35028       };
35029     } catch (std::exception& e) {
35030       {
35031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35032       };
35033     } catch (Dali::DaliException e) {
35034       {
35035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35036       };
35037     } catch (...) {
35038       {
35039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35040       };
35041     }
35042   }
35043
35044 }
35045
35046
35047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35048   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35049   Dali::Radian *arg2 = 0 ;
35050   Dali::Vector3 *arg3 = 0 ;
35051
35052   arg1 = (Dali::Actor *)jarg1;
35053   arg2 = (Dali::Radian *)jarg2;
35054   if (!arg2) {
35055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35056     return ;
35057   }
35058   arg3 = (Dali::Vector3 *)jarg3;
35059   if (!arg3) {
35060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35061     return ;
35062   }
35063   {
35064     try {
35065       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35066     } catch (std::out_of_range& e) {
35067       {
35068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35069       };
35070     } catch (std::exception& e) {
35071       {
35072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35073       };
35074     } catch (Dali::DaliException e) {
35075       {
35076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35077       };
35078     } catch (...) {
35079       {
35080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35081       };
35082     }
35083   }
35084
35085 }
35086
35087
35088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35089   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35090   Dali::Quaternion *arg2 = 0 ;
35091
35092   arg1 = (Dali::Actor *)jarg1;
35093   arg2 = (Dali::Quaternion *)jarg2;
35094   if (!arg2) {
35095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35096     return ;
35097   }
35098   {
35099     try {
35100       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35101     } catch (std::out_of_range& e) {
35102       {
35103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35104       };
35105     } catch (std::exception& e) {
35106       {
35107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35108       };
35109     } catch (Dali::DaliException e) {
35110       {
35111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35112       };
35113     } catch (...) {
35114       {
35115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35116       };
35117     }
35118   }
35119
35120 }
35121
35122
35123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35124   void * jresult ;
35125   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35126   Dali::Quaternion result;
35127
35128   arg1 = (Dali::Actor *)jarg1;
35129   {
35130     try {
35131       result = ((Dali::Actor const *)arg1)->GetCurrentOrientation();
35132     } catch (std::out_of_range& e) {
35133       {
35134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35135       };
35136     } catch (std::exception& e) {
35137       {
35138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35139       };
35140     } catch (Dali::DaliException e) {
35141       {
35142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35143       };
35144     } catch (...) {
35145       {
35146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35147       };
35148     }
35149   }
35150
35151   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35152   return jresult;
35153 }
35154
35155
35156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35157   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35158   bool arg2 ;
35159
35160   arg1 = (Dali::Actor *)jarg1;
35161   arg2 = jarg2 ? true : false;
35162   {
35163     try {
35164       (arg1)->SetInheritOrientation(arg2);
35165     } catch (std::out_of_range& e) {
35166       {
35167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35168       };
35169     } catch (std::exception& e) {
35170       {
35171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35172       };
35173     } catch (Dali::DaliException e) {
35174       {
35175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35176       };
35177     } catch (...) {
35178       {
35179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35180       };
35181     }
35182   }
35183
35184 }
35185
35186
35187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35188   unsigned int jresult ;
35189   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35190   bool result;
35191
35192   arg1 = (Dali::Actor *)jarg1;
35193   {
35194     try {
35195       result = (bool)((Dali::Actor const *)arg1)->IsOrientationInherited();
35196     } catch (std::out_of_range& e) {
35197       {
35198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35199       };
35200     } catch (std::exception& e) {
35201       {
35202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35203       };
35204     } catch (Dali::DaliException e) {
35205       {
35206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35207       };
35208     } catch (...) {
35209       {
35210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35211       };
35212     }
35213   }
35214
35215   jresult = result;
35216   return jresult;
35217 }
35218
35219
35220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35221   void * jresult ;
35222   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35223   Dali::Quaternion result;
35224
35225   arg1 = (Dali::Actor *)jarg1;
35226   {
35227     try {
35228       result = ((Dali::Actor const *)arg1)->GetCurrentWorldOrientation();
35229     } catch (std::out_of_range& e) {
35230       {
35231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35232       };
35233     } catch (std::exception& e) {
35234       {
35235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35236       };
35237     } catch (Dali::DaliException e) {
35238       {
35239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35240       };
35241     } catch (...) {
35242       {
35243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35244       };
35245     }
35246   }
35247
35248   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35249   return jresult;
35250 }
35251
35252
35253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35254   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35255   float arg2 ;
35256
35257   arg1 = (Dali::Actor *)jarg1;
35258   arg2 = (float)jarg2;
35259   {
35260     try {
35261       (arg1)->SetScale(arg2);
35262     } catch (std::out_of_range& e) {
35263       {
35264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35265       };
35266     } catch (std::exception& e) {
35267       {
35268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35269       };
35270     } catch (Dali::DaliException e) {
35271       {
35272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35273       };
35274     } catch (...) {
35275       {
35276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35277       };
35278     }
35279   }
35280
35281 }
35282
35283
35284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35285   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35286   float arg2 ;
35287   float arg3 ;
35288   float arg4 ;
35289
35290   arg1 = (Dali::Actor *)jarg1;
35291   arg2 = (float)jarg2;
35292   arg3 = (float)jarg3;
35293   arg4 = (float)jarg4;
35294   {
35295     try {
35296       (arg1)->SetScale(arg2,arg3,arg4);
35297     } catch (std::out_of_range& e) {
35298       {
35299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35300       };
35301     } catch (std::exception& e) {
35302       {
35303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35304       };
35305     } catch (Dali::DaliException e) {
35306       {
35307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35308       };
35309     } catch (...) {
35310       {
35311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35312       };
35313     }
35314   }
35315
35316 }
35317
35318
35319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35320   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35321   Dali::Vector3 *arg2 = 0 ;
35322
35323   arg1 = (Dali::Actor *)jarg1;
35324   arg2 = (Dali::Vector3 *)jarg2;
35325   if (!arg2) {
35326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35327     return ;
35328   }
35329   {
35330     try {
35331       (arg1)->SetScale((Dali::Vector3 const &)*arg2);
35332     } catch (std::out_of_range& e) {
35333       {
35334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35335       };
35336     } catch (std::exception& e) {
35337       {
35338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35339       };
35340     } catch (Dali::DaliException e) {
35341       {
35342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35343       };
35344     } catch (...) {
35345       {
35346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35347       };
35348     }
35349   }
35350
35351 }
35352
35353
35354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35355   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35356   Dali::Vector3 *arg2 = 0 ;
35357
35358   arg1 = (Dali::Actor *)jarg1;
35359   arg2 = (Dali::Vector3 *)jarg2;
35360   if (!arg2) {
35361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35362     return ;
35363   }
35364   {
35365     try {
35366       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35367     } catch (std::out_of_range& e) {
35368       {
35369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35370       };
35371     } catch (std::exception& e) {
35372       {
35373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35374       };
35375     } catch (Dali::DaliException e) {
35376       {
35377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35378       };
35379     } catch (...) {
35380       {
35381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35382       };
35383     }
35384   }
35385
35386 }
35387
35388
35389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35390   void * jresult ;
35391   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35392   Dali::Vector3 result;
35393
35394   arg1 = (Dali::Actor *)jarg1;
35395   {
35396     try {
35397       result = ((Dali::Actor const *)arg1)->GetCurrentScale();
35398     } catch (std::out_of_range& e) {
35399       {
35400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35401       };
35402     } catch (std::exception& e) {
35403       {
35404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35405       };
35406     } catch (Dali::DaliException e) {
35407       {
35408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35409       };
35410     } catch (...) {
35411       {
35412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35413       };
35414     }
35415   }
35416
35417   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35418   return jresult;
35419 }
35420
35421
35422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35423   void * jresult ;
35424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35425   Dali::Vector3 result;
35426
35427   arg1 = (Dali::Actor *)jarg1;
35428   {
35429     try {
35430       result = ((Dali::Actor const *)arg1)->GetCurrentWorldScale();
35431     } catch (std::out_of_range& e) {
35432       {
35433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35434       };
35435     } catch (std::exception& e) {
35436       {
35437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35438       };
35439     } catch (Dali::DaliException e) {
35440       {
35441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35442       };
35443     } catch (...) {
35444       {
35445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35446       };
35447     }
35448   }
35449
35450   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35451   return jresult;
35452 }
35453
35454
35455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35456   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35457   bool arg2 ;
35458
35459   arg1 = (Dali::Actor *)jarg1;
35460   arg2 = jarg2 ? true : false;
35461   {
35462     try {
35463       (arg1)->SetInheritScale(arg2);
35464     } catch (std::out_of_range& e) {
35465       {
35466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35467       };
35468     } catch (std::exception& e) {
35469       {
35470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35471       };
35472     } catch (Dali::DaliException e) {
35473       {
35474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35475       };
35476     } catch (...) {
35477       {
35478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35479       };
35480     }
35481   }
35482
35483 }
35484
35485
35486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35487   unsigned int jresult ;
35488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35489   bool result;
35490
35491   arg1 = (Dali::Actor *)jarg1;
35492   {
35493     try {
35494       result = (bool)((Dali::Actor const *)arg1)->IsScaleInherited();
35495     } catch (std::out_of_range& e) {
35496       {
35497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35498       };
35499     } catch (std::exception& e) {
35500       {
35501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35502       };
35503     } catch (Dali::DaliException e) {
35504       {
35505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35506       };
35507     } catch (...) {
35508       {
35509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35510       };
35511     }
35512   }
35513
35514   jresult = result;
35515   return jresult;
35516 }
35517
35518
35519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35520   void * jresult ;
35521   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35522   Dali::Matrix result;
35523
35524   arg1 = (Dali::Actor *)jarg1;
35525   {
35526     try {
35527       result = ((Dali::Actor const *)arg1)->GetCurrentWorldMatrix();
35528     } catch (std::out_of_range& e) {
35529       {
35530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35531       };
35532     } catch (std::exception& e) {
35533       {
35534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35535       };
35536     } catch (Dali::DaliException e) {
35537       {
35538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35539       };
35540     } catch (...) {
35541       {
35542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35543       };
35544     }
35545   }
35546
35547   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35548   return jresult;
35549 }
35550
35551
35552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35554   bool arg2 ;
35555
35556   arg1 = (Dali::Actor *)jarg1;
35557   arg2 = jarg2 ? true : false;
35558   {
35559     try {
35560       (arg1)->SetVisible(arg2);
35561     } catch (std::out_of_range& e) {
35562       {
35563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35564       };
35565     } catch (std::exception& e) {
35566       {
35567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35568       };
35569     } catch (Dali::DaliException e) {
35570       {
35571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35572       };
35573     } catch (...) {
35574       {
35575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35576       };
35577     }
35578   }
35579
35580 }
35581
35582
35583 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35584   unsigned int jresult ;
35585   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35586   bool result;
35587
35588   arg1 = (Dali::Actor *)jarg1;
35589   {
35590     try {
35591       result = (bool)((Dali::Actor const *)arg1)->IsVisible();
35592     } catch (std::out_of_range& e) {
35593       {
35594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35595       };
35596     } catch (std::exception& e) {
35597       {
35598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35599       };
35600     } catch (Dali::DaliException e) {
35601       {
35602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35603       };
35604     } catch (...) {
35605       {
35606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35607       };
35608     }
35609   }
35610
35611   jresult = result;
35612   return jresult;
35613 }
35614
35615
35616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35617   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35618   float arg2 ;
35619
35620   arg1 = (Dali::Actor *)jarg1;
35621   arg2 = (float)jarg2;
35622   {
35623     try {
35624       (arg1)->SetOpacity(arg2);
35625     } catch (std::out_of_range& e) {
35626       {
35627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35628       };
35629     } catch (std::exception& e) {
35630       {
35631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35632       };
35633     } catch (Dali::DaliException e) {
35634       {
35635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35636       };
35637     } catch (...) {
35638       {
35639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35640       };
35641     }
35642   }
35643
35644 }
35645
35646
35647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35648   float jresult ;
35649   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35650   float result;
35651
35652   arg1 = (Dali::Actor *)jarg1;
35653   {
35654     try {
35655       result = (float)((Dali::Actor const *)arg1)->GetCurrentOpacity();
35656     } catch (std::out_of_range& e) {
35657       {
35658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35659       };
35660     } catch (std::exception& e) {
35661       {
35662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35663       };
35664     } catch (Dali::DaliException e) {
35665       {
35666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35667       };
35668     } catch (...) {
35669       {
35670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35671       };
35672     }
35673   }
35674
35675   jresult = result;
35676   return jresult;
35677 }
35678
35679
35680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35681   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35682   Dali::Vector4 *arg2 = 0 ;
35683
35684   arg1 = (Dali::Actor *)jarg1;
35685   arg2 = (Dali::Vector4 *)jarg2;
35686   if (!arg2) {
35687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35688     return ;
35689   }
35690   {
35691     try {
35692       (arg1)->SetColor((Dali::Vector4 const &)*arg2);
35693     } catch (std::out_of_range& e) {
35694       {
35695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35696       };
35697     } catch (std::exception& e) {
35698       {
35699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35700       };
35701     } catch (Dali::DaliException e) {
35702       {
35703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35704       };
35705     } catch (...) {
35706       {
35707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35708       };
35709     }
35710   }
35711
35712 }
35713
35714
35715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35716   void * jresult ;
35717   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35718   Dali::Vector4 result;
35719
35720   arg1 = (Dali::Actor *)jarg1;
35721   {
35722     try {
35723       result = ((Dali::Actor const *)arg1)->GetCurrentColor();
35724     } catch (std::out_of_range& e) {
35725       {
35726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35727       };
35728     } catch (std::exception& e) {
35729       {
35730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35731       };
35732     } catch (Dali::DaliException e) {
35733       {
35734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35735       };
35736     } catch (...) {
35737       {
35738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35739       };
35740     }
35741   }
35742
35743   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35744   return jresult;
35745 }
35746
35747
35748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35749   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35750   Dali::ColorMode arg2 ;
35751
35752   arg1 = (Dali::Actor *)jarg1;
35753   arg2 = (Dali::ColorMode)jarg2;
35754   {
35755     try {
35756       (arg1)->SetColorMode(arg2);
35757     } catch (std::out_of_range& e) {
35758       {
35759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35760       };
35761     } catch (std::exception& e) {
35762       {
35763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35764       };
35765     } catch (Dali::DaliException e) {
35766       {
35767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35768       };
35769     } catch (...) {
35770       {
35771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35772       };
35773     }
35774   }
35775
35776 }
35777
35778
35779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35780   int jresult ;
35781   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35782   Dali::ColorMode result;
35783
35784   arg1 = (Dali::Actor *)jarg1;
35785   {
35786     try {
35787       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetColorMode();
35788     } catch (std::out_of_range& e) {
35789       {
35790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35791       };
35792     } catch (std::exception& e) {
35793       {
35794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35795       };
35796     } catch (Dali::DaliException e) {
35797       {
35798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35799       };
35800     } catch (...) {
35801       {
35802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35803       };
35804     }
35805   }
35806
35807   jresult = (int)result;
35808   return jresult;
35809 }
35810
35811
35812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35813   void * jresult ;
35814   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35815   Dali::Vector4 result;
35816
35817   arg1 = (Dali::Actor *)jarg1;
35818   {
35819     try {
35820       result = ((Dali::Actor const *)arg1)->GetCurrentWorldColor();
35821     } catch (std::out_of_range& e) {
35822       {
35823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35824       };
35825     } catch (std::exception& e) {
35826       {
35827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35828       };
35829     } catch (Dali::DaliException e) {
35830       {
35831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35832       };
35833     } catch (...) {
35834       {
35835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35836       };
35837     }
35838   }
35839
35840   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35841   return jresult;
35842 }
35843
35844
35845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35846   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35847   Dali::DrawMode::Type arg2 ;
35848
35849   arg1 = (Dali::Actor *)jarg1;
35850   arg2 = (Dali::DrawMode::Type)jarg2;
35851   {
35852     try {
35853       (arg1)->SetDrawMode(arg2);
35854     } catch (std::out_of_range& e) {
35855       {
35856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35857       };
35858     } catch (std::exception& e) {
35859       {
35860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35861       };
35862     } catch (Dali::DaliException e) {
35863       {
35864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35865       };
35866     } catch (...) {
35867       {
35868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35869       };
35870     }
35871   }
35872
35873 }
35874
35875
35876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35877   int jresult ;
35878   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35879   Dali::DrawMode::Type result;
35880
35881   arg1 = (Dali::Actor *)jarg1;
35882   {
35883     try {
35884       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetDrawMode();
35885     } catch (std::out_of_range& e) {
35886       {
35887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35888       };
35889     } catch (std::exception& e) {
35890       {
35891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35892       };
35893     } catch (Dali::DaliException e) {
35894       {
35895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35896       };
35897     } catch (...) {
35898       {
35899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35900       };
35901     }
35902   }
35903
35904   jresult = (int)result;
35905   return jresult;
35906 }
35907
35908
35909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35910   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35911   bool arg2 ;
35912
35913   arg1 = (Dali::Actor *)jarg1;
35914   arg2 = jarg2 ? true : false;
35915   {
35916     try {
35917       (arg1)->SetSensitive(arg2);
35918     } catch (std::out_of_range& e) {
35919       {
35920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35921       };
35922     } catch (std::exception& e) {
35923       {
35924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35925       };
35926     } catch (Dali::DaliException e) {
35927       {
35928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35929       };
35930     } catch (...) {
35931       {
35932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35933       };
35934     }
35935   }
35936
35937 }
35938
35939
35940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35941   unsigned int jresult ;
35942   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35943   bool result;
35944
35945   arg1 = (Dali::Actor *)jarg1;
35946   {
35947     try {
35948       result = (bool)((Dali::Actor const *)arg1)->IsSensitive();
35949     } catch (std::out_of_range& e) {
35950       {
35951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35952       };
35953     } catch (std::exception& e) {
35954       {
35955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35956       };
35957     } catch (Dali::DaliException e) {
35958       {
35959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35960       };
35961     } catch (...) {
35962       {
35963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35964       };
35965     }
35966   }
35967
35968   jresult = result;
35969   return jresult;
35970 }
35971
35972
35973 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35974   unsigned int jresult ;
35975   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35976   float *arg2 = 0 ;
35977   float *arg3 = 0 ;
35978   float arg4 ;
35979   float arg5 ;
35980   bool result;
35981
35982   arg1 = (Dali::Actor *)jarg1;
35983   arg2 = (float *)jarg2;
35984   arg3 = (float *)jarg3;
35985   arg4 = (float)jarg4;
35986   arg5 = (float)jarg5;
35987   {
35988     try {
35989       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35990     } catch (std::out_of_range& e) {
35991       {
35992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35993       };
35994     } catch (std::exception& e) {
35995       {
35996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35997       };
35998     } catch (Dali::DaliException e) {
35999       {
36000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36001       };
36002     } catch (...) {
36003       {
36004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36005       };
36006     }
36007   }
36008
36009   jresult = result;
36010   return jresult;
36011 }
36012
36013
36014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36015   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36016   bool arg2 ;
36017
36018   arg1 = (Dali::Actor *)jarg1;
36019   arg2 = jarg2 ? true : false;
36020   {
36021     try {
36022       (arg1)->SetLeaveRequired(arg2);
36023     } catch (std::out_of_range& e) {
36024       {
36025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36026       };
36027     } catch (std::exception& e) {
36028       {
36029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36030       };
36031     } catch (Dali::DaliException e) {
36032       {
36033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36034       };
36035     } catch (...) {
36036       {
36037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36038       };
36039     }
36040   }
36041
36042 }
36043
36044
36045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36046   unsigned int jresult ;
36047   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36048   bool result;
36049
36050   arg1 = (Dali::Actor *)jarg1;
36051   {
36052     try {
36053       result = (bool)((Dali::Actor const *)arg1)->GetLeaveRequired();
36054     } catch (std::out_of_range& e) {
36055       {
36056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36057       };
36058     } catch (std::exception& e) {
36059       {
36060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36061       };
36062     } catch (Dali::DaliException e) {
36063       {
36064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36065       };
36066     } catch (...) {
36067       {
36068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36069       };
36070     }
36071   }
36072
36073   jresult = result;
36074   return jresult;
36075 }
36076
36077
36078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36080   bool arg2 ;
36081
36082   arg1 = (Dali::Actor *)jarg1;
36083   arg2 = jarg2 ? true : false;
36084   {
36085     try {
36086       (arg1)->SetKeyboardFocusable(arg2);
36087     } catch (std::out_of_range& e) {
36088       {
36089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36090       };
36091     } catch (std::exception& e) {
36092       {
36093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36094       };
36095     } catch (Dali::DaliException e) {
36096       {
36097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36098       };
36099     } catch (...) {
36100       {
36101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36102       };
36103     }
36104   }
36105
36106 }
36107
36108
36109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36110   unsigned int jresult ;
36111   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36112   bool result;
36113
36114   arg1 = (Dali::Actor *)jarg1;
36115   {
36116     try {
36117       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36118     } catch (std::out_of_range& e) {
36119       {
36120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36121       };
36122     } catch (std::exception& e) {
36123       {
36124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36125       };
36126     } catch (Dali::DaliException e) {
36127       {
36128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36129       };
36130     } catch (...) {
36131       {
36132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36133       };
36134     }
36135   }
36136
36137   jresult = result;
36138   return jresult;
36139 }
36140
36141
36142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36144   Dali::ResizePolicy::Type arg2 ;
36145   Dali::Dimension::Type arg3 ;
36146
36147   arg1 = (Dali::Actor *)jarg1;
36148   arg2 = (Dali::ResizePolicy::Type)jarg2;
36149   arg3 = (Dali::Dimension::Type)jarg3;
36150   {
36151     try {
36152       (arg1)->SetResizePolicy(arg2,arg3);
36153     } catch (std::out_of_range& e) {
36154       {
36155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36156       };
36157     } catch (std::exception& e) {
36158       {
36159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36160       };
36161     } catch (Dali::DaliException e) {
36162       {
36163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36164       };
36165     } catch (...) {
36166       {
36167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36168       };
36169     }
36170   }
36171
36172 }
36173
36174
36175 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36176   int jresult ;
36177   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36178   Dali::Dimension::Type arg2 ;
36179   Dali::ResizePolicy::Type result;
36180
36181   arg1 = (Dali::Actor *)jarg1;
36182   arg2 = (Dali::Dimension::Type)jarg2;
36183   {
36184     try {
36185       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36186     } catch (std::out_of_range& e) {
36187       {
36188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36189       };
36190     } catch (std::exception& e) {
36191       {
36192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36193       };
36194     } catch (Dali::DaliException e) {
36195       {
36196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36197       };
36198     } catch (...) {
36199       {
36200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36201       };
36202     }
36203   }
36204
36205   jresult = (int)result;
36206   return jresult;
36207 }
36208
36209
36210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36211   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36212   Dali::SizeScalePolicy::Type arg2 ;
36213
36214   arg1 = (Dali::Actor *)jarg1;
36215   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36216   {
36217     try {
36218       (arg1)->SetSizeScalePolicy(arg2);
36219     } catch (std::out_of_range& e) {
36220       {
36221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36222       };
36223     } catch (std::exception& e) {
36224       {
36225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36226       };
36227     } catch (Dali::DaliException e) {
36228       {
36229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36230       };
36231     } catch (...) {
36232       {
36233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36234       };
36235     }
36236   }
36237
36238 }
36239
36240
36241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36242   int jresult ;
36243   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36244   Dali::SizeScalePolicy::Type result;
36245
36246   arg1 = (Dali::Actor *)jarg1;
36247   {
36248     try {
36249       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetSizeScalePolicy();
36250     } catch (std::out_of_range& e) {
36251       {
36252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36253       };
36254     } catch (std::exception& e) {
36255       {
36256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36257       };
36258     } catch (Dali::DaliException e) {
36259       {
36260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36261       };
36262     } catch (...) {
36263       {
36264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36265       };
36266     }
36267   }
36268
36269   jresult = (int)result;
36270   return jresult;
36271 }
36272
36273
36274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36275   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36276   Dali::Vector3 *arg2 = 0 ;
36277
36278   arg1 = (Dali::Actor *)jarg1;
36279   arg2 = (Dali::Vector3 *)jarg2;
36280   if (!arg2) {
36281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36282     return ;
36283   }
36284   {
36285     try {
36286       (arg1)->SetSizeModeFactor((Dali::Vector3 const &)*arg2);
36287     } catch (std::out_of_range& e) {
36288       {
36289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36290       };
36291     } catch (std::exception& e) {
36292       {
36293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36294       };
36295     } catch (Dali::DaliException e) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36298       };
36299     } catch (...) {
36300       {
36301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36302       };
36303     }
36304   }
36305
36306 }
36307
36308
36309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36310   void * jresult ;
36311   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36312   Dali::Vector3 result;
36313
36314   arg1 = (Dali::Actor *)jarg1;
36315   {
36316     try {
36317       result = ((Dali::Actor const *)arg1)->GetSizeModeFactor();
36318     } catch (std::out_of_range& e) {
36319       {
36320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36321       };
36322     } catch (std::exception& e) {
36323       {
36324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36325       };
36326     } catch (Dali::DaliException e) {
36327       {
36328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36329       };
36330     } catch (...) {
36331       {
36332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36333       };
36334     }
36335   }
36336
36337   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36338   return jresult;
36339 }
36340
36341
36342 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36343   float jresult ;
36344   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36345   float arg2 ;
36346   float result;
36347
36348   arg1 = (Dali::Actor *)jarg1;
36349   arg2 = (float)jarg2;
36350   {
36351     try {
36352       result = (float)(arg1)->GetHeightForWidth(arg2);
36353     } catch (std::out_of_range& e) {
36354       {
36355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36356       };
36357     } catch (std::exception& e) {
36358       {
36359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (Dali::DaliException e) {
36362       {
36363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36364       };
36365     } catch (...) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36368       };
36369     }
36370   }
36371
36372   jresult = result;
36373   return jresult;
36374 }
36375
36376
36377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36378   float jresult ;
36379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36380   float arg2 ;
36381   float result;
36382
36383   arg1 = (Dali::Actor *)jarg1;
36384   arg2 = (float)jarg2;
36385   {
36386     try {
36387       result = (float)(arg1)->GetWidthForHeight(arg2);
36388     } catch (std::out_of_range& e) {
36389       {
36390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36391       };
36392     } catch (std::exception& e) {
36393       {
36394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36395       };
36396     } catch (Dali::DaliException e) {
36397       {
36398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36399       };
36400     } catch (...) {
36401       {
36402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36403       };
36404     }
36405   }
36406
36407   jresult = result;
36408   return jresult;
36409 }
36410
36411
36412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36413   float jresult ;
36414   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36415   Dali::Dimension::Type arg2 ;
36416   float result;
36417
36418   arg1 = (Dali::Actor *)jarg1;
36419   arg2 = (Dali::Dimension::Type)jarg2;
36420   {
36421     try {
36422       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36423     } catch (std::out_of_range& e) {
36424       {
36425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36426       };
36427     } catch (std::exception& e) {
36428       {
36429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36430       };
36431     } catch (Dali::DaliException e) {
36432       {
36433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36434       };
36435     } catch (...) {
36436       {
36437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36438       };
36439     }
36440   }
36441
36442   jresult = result;
36443   return jresult;
36444 }
36445
36446
36447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36448   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36449   Dali::Padding *arg2 = 0 ;
36450
36451   arg1 = (Dali::Actor *)jarg1;
36452   arg2 = (Dali::Padding *)jarg2;
36453   if (!arg2) {
36454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36455     return ;
36456   }
36457   {
36458     try {
36459       (arg1)->SetPadding((Dali::Padding const &)*arg2);
36460     } catch (std::out_of_range& e) {
36461       {
36462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36463       };
36464     } catch (std::exception& e) {
36465       {
36466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36467       };
36468     } catch (Dali::DaliException e) {
36469       {
36470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36471       };
36472     } catch (...) {
36473       {
36474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36475       };
36476     }
36477   }
36478
36479 }
36480
36481
36482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36483   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36484   Dali::Padding *arg2 = 0 ;
36485
36486   arg1 = (Dali::Actor *)jarg1;
36487   arg2 = (Dali::Padding *)jarg2;
36488   if (!arg2) {
36489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36490     return ;
36491   }
36492   {
36493     try {
36494       ((Dali::Actor const *)arg1)->GetPadding(*arg2);
36495     } catch (std::out_of_range& e) {
36496       {
36497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36498       };
36499     } catch (std::exception& e) {
36500       {
36501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36502       };
36503     } catch (Dali::DaliException e) {
36504       {
36505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36506       };
36507     } catch (...) {
36508       {
36509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36510       };
36511     }
36512   }
36513
36514 }
36515
36516
36517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36518   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36519   Dali::Vector2 *arg2 = 0 ;
36520
36521   arg1 = (Dali::Actor *)jarg1;
36522   arg2 = (Dali::Vector2 *)jarg2;
36523   if (!arg2) {
36524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36525     return ;
36526   }
36527   {
36528     try {
36529       (arg1)->SetMinimumSize((Dali::Vector2 const &)*arg2);
36530     } catch (std::out_of_range& e) {
36531       {
36532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36533       };
36534     } catch (std::exception& e) {
36535       {
36536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36537       };
36538     } catch (Dali::DaliException e) {
36539       {
36540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36541       };
36542     } catch (...) {
36543       {
36544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36545       };
36546     }
36547   }
36548
36549 }
36550
36551
36552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36553   void * jresult ;
36554   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36555   Dali::Vector2 result;
36556
36557   arg1 = (Dali::Actor *)jarg1;
36558   {
36559     try {
36560       result = (arg1)->GetMinimumSize();
36561     } catch (std::out_of_range& e) {
36562       {
36563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36564       };
36565     } catch (std::exception& e) {
36566       {
36567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36568       };
36569     } catch (Dali::DaliException e) {
36570       {
36571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36572       };
36573     } catch (...) {
36574       {
36575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36576       };
36577     }
36578   }
36579
36580   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36581   return jresult;
36582 }
36583
36584
36585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36587   Dali::Vector2 *arg2 = 0 ;
36588
36589   arg1 = (Dali::Actor *)jarg1;
36590   arg2 = (Dali::Vector2 *)jarg2;
36591   if (!arg2) {
36592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36593     return ;
36594   }
36595   {
36596     try {
36597       (arg1)->SetMaximumSize((Dali::Vector2 const &)*arg2);
36598     } catch (std::out_of_range& e) {
36599       {
36600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36601       };
36602     } catch (std::exception& e) {
36603       {
36604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36605       };
36606     } catch (Dali::DaliException e) {
36607       {
36608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36609       };
36610     } catch (...) {
36611       {
36612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36613       };
36614     }
36615   }
36616
36617 }
36618
36619
36620 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36621   void * jresult ;
36622   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36623   Dali::Vector2 result;
36624
36625   arg1 = (Dali::Actor *)jarg1;
36626   {
36627     try {
36628       result = (arg1)->GetMaximumSize();
36629     } catch (std::out_of_range& e) {
36630       {
36631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36632       };
36633     } catch (std::exception& e) {
36634       {
36635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36636       };
36637     } catch (Dali::DaliException e) {
36638       {
36639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36640       };
36641     } catch (...) {
36642       {
36643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36644       };
36645     }
36646   }
36647
36648   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36649   return jresult;
36650 }
36651
36652
36653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36654   int jresult ;
36655   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36656   int result;
36657
36658   arg1 = (Dali::Actor *)jarg1;
36659   {
36660     try {
36661       result = (int)(arg1)->GetHierarchyDepth();
36662       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36663     } catch (std::out_of_range& e) {
36664       {
36665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36666       };
36667     } catch (std::exception& e) {
36668       {
36669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36670       };
36671     } catch (Dali::DaliException e) {
36672       {
36673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36674       };
36675     } catch (...) {
36676       {
36677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36678       };
36679     }
36680   }
36681
36682   jresult = result;
36683   return jresult;
36684 }
36685
36686
36687 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36688   unsigned int jresult ;
36689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36690   Dali::Renderer *arg2 = 0 ;
36691   unsigned int result;
36692
36693   arg1 = (Dali::Actor *)jarg1;
36694   arg2 = (Dali::Renderer *)jarg2;
36695   if (!arg2) {
36696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36697     return 0;
36698   }
36699   {
36700     try {
36701       result = (unsigned int)(arg1)->AddRenderer(*arg2);
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_GetRendererCount(void * jarg1) {
36727   unsigned int jresult ;
36728   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36729   unsigned int result;
36730
36731   arg1 = (Dali::Actor *)jarg1;
36732   {
36733     try {
36734       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36735     } catch (std::out_of_range& e) {
36736       {
36737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36738       };
36739     } catch (std::exception& e) {
36740       {
36741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36742       };
36743     } catch (Dali::DaliException e) {
36744       {
36745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36746       };
36747     } catch (...) {
36748       {
36749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36750       };
36751     }
36752   }
36753
36754   jresult = result;
36755   return jresult;
36756 }
36757
36758
36759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36760   void * jresult ;
36761   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36762   unsigned int arg2 ;
36763   Dali::Renderer result;
36764
36765   arg1 = (Dali::Actor *)jarg1;
36766   arg2 = (unsigned int)jarg2;
36767   {
36768     try {
36769       result = (arg1)->GetRendererAt(arg2);
36770     } catch (std::out_of_range& e) {
36771       {
36772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36773       };
36774     } catch (std::exception& e) {
36775       {
36776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36777       };
36778     } catch (Dali::DaliException e) {
36779       {
36780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36781       };
36782     } catch (...) {
36783       {
36784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36785       };
36786     }
36787   }
36788
36789   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36790   return jresult;
36791 }
36792
36793
36794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36795   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36796   Dali::Renderer *arg2 = 0 ;
36797
36798   arg1 = (Dali::Actor *)jarg1;
36799   arg2 = (Dali::Renderer *)jarg2;
36800   if (!arg2) {
36801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36802     return ;
36803   }
36804   {
36805     try {
36806       (arg1)->RemoveRenderer(*arg2);
36807     } catch (std::out_of_range& e) {
36808       {
36809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36810       };
36811     } catch (std::exception& e) {
36812       {
36813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36814       };
36815     } catch (Dali::DaliException e) {
36816       {
36817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36818       };
36819     } catch (...) {
36820       {
36821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36822       };
36823     }
36824   }
36825
36826 }
36827
36828
36829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36830   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36831   unsigned int arg2 ;
36832
36833   arg1 = (Dali::Actor *)jarg1;
36834   arg2 = (unsigned int)jarg2;
36835   {
36836     try {
36837       (arg1)->RemoveRenderer(arg2);
36838     } catch (std::out_of_range& e) {
36839       {
36840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36841       };
36842     } catch (std::exception& e) {
36843       {
36844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36845       };
36846     } catch (Dali::DaliException e) {
36847       {
36848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36849       };
36850     } catch (...) {
36851       {
36852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36853       };
36854     }
36855   }
36856
36857 }
36858
36859
36860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
36861   void * jresult ;
36862   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36863   Dali::Actor::TouchSignalType *result = 0 ;
36864
36865   arg1 = (Dali::Actor *)jarg1;
36866   {
36867     try {
36868       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
36869     } catch (std::out_of_range& e) {
36870       {
36871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36872       };
36873     } catch (std::exception& e) {
36874       {
36875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36876       };
36877     } catch (Dali::DaliException e) {
36878       {
36879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36880       };
36881     } catch (...) {
36882       {
36883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36884       };
36885     }
36886   }
36887
36888   jresult = (void *)result;
36889   return jresult;
36890 }
36891
36892
36893 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36894   void * jresult ;
36895   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36896   Dali::Actor::TouchDataSignalType *result = 0 ;
36897
36898   arg1 = (Dali::Actor *)jarg1;
36899   {
36900     try {
36901       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36902     } catch (std::out_of_range& e) {
36903       {
36904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36905       };
36906     } catch (std::exception& e) {
36907       {
36908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36909       };
36910     } catch (Dali::DaliException e) {
36911       {
36912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36913       };
36914     } catch (...) {
36915       {
36916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36917       };
36918     }
36919   }
36920
36921   jresult = (void *)result;
36922   return jresult;
36923 }
36924
36925
36926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36927   void * jresult ;
36928   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36929   Dali::Actor::HoverSignalType *result = 0 ;
36930
36931   arg1 = (Dali::Actor *)jarg1;
36932   {
36933     try {
36934       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36935     } catch (std::out_of_range& e) {
36936       {
36937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36938       };
36939     } catch (std::exception& e) {
36940       {
36941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36942       };
36943     } catch (Dali::DaliException e) {
36944       {
36945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36946       };
36947     } catch (...) {
36948       {
36949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36950       };
36951     }
36952   }
36953
36954   jresult = (void *)result;
36955   return jresult;
36956 }
36957
36958
36959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36960   void * jresult ;
36961   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36962   Dali::Actor::WheelEventSignalType *result = 0 ;
36963
36964   arg1 = (Dali::Actor *)jarg1;
36965   {
36966     try {
36967       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36968     } catch (std::out_of_range& e) {
36969       {
36970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36971       };
36972     } catch (std::exception& e) {
36973       {
36974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36975       };
36976     } catch (Dali::DaliException e) {
36977       {
36978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36979       };
36980     } catch (...) {
36981       {
36982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36983       };
36984     }
36985   }
36986
36987   jresult = (void *)result;
36988   return jresult;
36989 }
36990
36991
36992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
36993   void * jresult ;
36994   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36995   Dali::Actor::OnStageSignalType *result = 0 ;
36996
36997   arg1 = (Dali::Actor *)jarg1;
36998   {
36999     try {
37000       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37001     } catch (std::out_of_range& e) {
37002       {
37003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37004       };
37005     } catch (std::exception& e) {
37006       {
37007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37008       };
37009     } catch (Dali::DaliException e) {
37010       {
37011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37012       };
37013     } catch (...) {
37014       {
37015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37016       };
37017     }
37018   }
37019
37020   jresult = (void *)result;
37021   return jresult;
37022 }
37023
37024
37025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37026   void * jresult ;
37027   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37028   Dali::Actor::OffStageSignalType *result = 0 ;
37029
37030   arg1 = (Dali::Actor *)jarg1;
37031   {
37032     try {
37033       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37034     } catch (std::out_of_range& e) {
37035       {
37036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37037       };
37038     } catch (std::exception& e) {
37039       {
37040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37041       };
37042     } catch (Dali::DaliException e) {
37043       {
37044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37045       };
37046     } catch (...) {
37047       {
37048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37049       };
37050     }
37051   }
37052
37053   jresult = (void *)result;
37054   return jresult;
37055 }
37056
37057
37058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37059   void * jresult ;
37060   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37061   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37062
37063   arg1 = (Dali::Actor *)jarg1;
37064   {
37065     try {
37066       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37067     } catch (std::out_of_range& e) {
37068       {
37069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37070       };
37071     } catch (std::exception& e) {
37072       {
37073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37074       };
37075     } catch (Dali::DaliException e) {
37076       {
37077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37078       };
37079     } catch (...) {
37080       {
37081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37082       };
37083     }
37084   }
37085
37086   jresult = (void *)result;
37087   return jresult;
37088 }
37089
37090
37091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37092   Dali::Actor *arg1 = 0 ;
37093
37094   arg1 = (Dali::Actor *)jarg1;
37095   if (!arg1) {
37096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37097     return ;
37098   }
37099   {
37100     try {
37101       Dali::UnparentAndReset(*arg1);
37102     } catch (std::out_of_range& e) {
37103       {
37104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37105       };
37106     } catch (std::exception& e) {
37107       {
37108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37109       };
37110     } catch (Dali::DaliException e) {
37111       {
37112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37113       };
37114     } catch (...) {
37115       {
37116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37117       };
37118     }
37119   }
37120
37121 }
37122
37123
37124 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37125   int jresult ;
37126   int result;
37127
37128   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37129   jresult = (int)result;
37130   return jresult;
37131 }
37132
37133
37134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37135   int jresult ;
37136   int result;
37137
37138   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37139   jresult = (int)result;
37140   return jresult;
37141 }
37142
37143
37144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37145   int jresult ;
37146   int result;
37147
37148   result = (int)Dali::Layer::Property::BEHAVIOR;
37149   jresult = (int)result;
37150   return jresult;
37151 }
37152
37153
37154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37155   void * jresult ;
37156   Dali::Layer::Property *result = 0 ;
37157
37158   {
37159     try {
37160       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37161     } catch (std::out_of_range& e) {
37162       {
37163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37164       };
37165     } catch (std::exception& e) {
37166       {
37167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37168       };
37169     } catch (Dali::DaliException e) {
37170       {
37171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37172       };
37173     } catch (...) {
37174       {
37175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37176       };
37177     }
37178   }
37179
37180   jresult = (void *)result;
37181   return jresult;
37182 }
37183
37184
37185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37186   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37187
37188   arg1 = (Dali::Layer::Property *)jarg1;
37189   {
37190     try {
37191       delete arg1;
37192     } catch (std::out_of_range& e) {
37193       {
37194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37195       };
37196     } catch (std::exception& e) {
37197       {
37198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37199       };
37200     } catch (Dali::DaliException e) {
37201       {
37202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37203       };
37204     } catch (...) {
37205       {
37206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37207       };
37208     }
37209   }
37210
37211 }
37212
37213
37214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37215   void * jresult ;
37216   Dali::Layer *result = 0 ;
37217
37218   {
37219     try {
37220       result = (Dali::Layer *)new Dali::Layer();
37221     } catch (std::out_of_range& e) {
37222       {
37223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37224       };
37225     } catch (std::exception& e) {
37226       {
37227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37228       };
37229     } catch (Dali::DaliException e) {
37230       {
37231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37232       };
37233     } catch (...) {
37234       {
37235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37236       };
37237     }
37238   }
37239
37240   jresult = (void *)result;
37241   return jresult;
37242 }
37243
37244
37245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37246   void * jresult ;
37247   Dali::Layer result;
37248
37249   {
37250     try {
37251       result = Dali::Layer::New();
37252     } catch (std::out_of_range& e) {
37253       {
37254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37255       };
37256     } catch (std::exception& e) {
37257       {
37258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37259       };
37260     } catch (Dali::DaliException e) {
37261       {
37262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37263       };
37264     } catch (...) {
37265       {
37266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37267       };
37268     }
37269   }
37270
37271   jresult = new Dali::Layer((const Dali::Layer &)result);
37272   return jresult;
37273 }
37274
37275
37276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37277   void * jresult ;
37278   Dali::BaseHandle arg1 ;
37279   Dali::BaseHandle *argp1 ;
37280   Dali::Layer result;
37281
37282   argp1 = (Dali::BaseHandle *)jarg1;
37283   if (!argp1) {
37284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37285     return 0;
37286   }
37287   arg1 = *argp1;
37288   {
37289     try {
37290       result = Dali::Layer::DownCast(arg1);
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_delete_Layer(void * jarg1) {
37316   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37317
37318   arg1 = (Dali::Layer *)jarg1;
37319   {
37320     try {
37321       delete arg1;
37322     } catch (std::out_of_range& e) {
37323       {
37324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37325       };
37326     } catch (std::exception& e) {
37327       {
37328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37329       };
37330     } catch (Dali::DaliException e) {
37331       {
37332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37333       };
37334     } catch (...) {
37335       {
37336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37337       };
37338     }
37339   }
37340
37341 }
37342
37343
37344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37345   void * jresult ;
37346   Dali::Layer *arg1 = 0 ;
37347   Dali::Layer *result = 0 ;
37348
37349   arg1 = (Dali::Layer *)jarg1;
37350   if (!arg1) {
37351     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37352     return 0;
37353   }
37354   {
37355     try {
37356       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37357     } catch (std::out_of_range& e) {
37358       {
37359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37360       };
37361     } catch (std::exception& e) {
37362       {
37363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37364       };
37365     } catch (Dali::DaliException e) {
37366       {
37367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37368       };
37369     } catch (...) {
37370       {
37371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37372       };
37373     }
37374   }
37375
37376   jresult = (void *)result;
37377   return jresult;
37378 }
37379
37380
37381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37382   void * jresult ;
37383   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37384   Dali::Layer *arg2 = 0 ;
37385   Dali::Layer *result = 0 ;
37386
37387   arg1 = (Dali::Layer *)jarg1;
37388   arg2 = (Dali::Layer *)jarg2;
37389   if (!arg2) {
37390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37391     return 0;
37392   }
37393   {
37394     try {
37395       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
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 unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37421   unsigned int jresult ;
37422   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37423   unsigned int result;
37424
37425   arg1 = (Dali::Layer *)jarg1;
37426   {
37427     try {
37428       result = (unsigned int)((Dali::Layer const *)arg1)->GetDepth();
37429     } catch (std::out_of_range& e) {
37430       {
37431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37432       };
37433     } catch (std::exception& e) {
37434       {
37435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37436       };
37437     } catch (Dali::DaliException e) {
37438       {
37439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37440       };
37441     } catch (...) {
37442       {
37443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37444       };
37445     }
37446   }
37447
37448   jresult = result;
37449   return jresult;
37450 }
37451
37452
37453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37454   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37455
37456   arg1 = (Dali::Layer *)jarg1;
37457   {
37458     try {
37459       (arg1)->Raise();
37460     } catch (std::out_of_range& e) {
37461       {
37462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37463       };
37464     } catch (std::exception& e) {
37465       {
37466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37467       };
37468     } catch (Dali::DaliException e) {
37469       {
37470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37471       };
37472     } catch (...) {
37473       {
37474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37475       };
37476     }
37477   }
37478
37479 }
37480
37481
37482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37483   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37484
37485   arg1 = (Dali::Layer *)jarg1;
37486   {
37487     try {
37488       (arg1)->Lower();
37489     } catch (std::out_of_range& e) {
37490       {
37491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37492       };
37493     } catch (std::exception& e) {
37494       {
37495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37496       };
37497     } catch (Dali::DaliException e) {
37498       {
37499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37500       };
37501     } catch (...) {
37502       {
37503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37504       };
37505     }
37506   }
37507
37508 }
37509
37510
37511 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37512   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37513   Dali::Layer arg2 ;
37514   Dali::Layer *argp2 ;
37515
37516   arg1 = (Dali::Layer *)jarg1;
37517   argp2 = (Dali::Layer *)jarg2;
37518   if (!argp2) {
37519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37520     return ;
37521   }
37522   arg2 = *argp2;
37523   {
37524     try {
37525       (arg1)->RaiseAbove(arg2);
37526     } catch (std::out_of_range& e) {
37527       {
37528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37529       };
37530     } catch (std::exception& e) {
37531       {
37532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37533       };
37534     } catch (Dali::DaliException e) {
37535       {
37536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37537       };
37538     } catch (...) {
37539       {
37540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37541       };
37542     }
37543   }
37544
37545 }
37546
37547
37548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37549   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37550   Dali::Layer arg2 ;
37551   Dali::Layer *argp2 ;
37552
37553   arg1 = (Dali::Layer *)jarg1;
37554   argp2 = (Dali::Layer *)jarg2;
37555   if (!argp2) {
37556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37557     return ;
37558   }
37559   arg2 = *argp2;
37560   {
37561     try {
37562       (arg1)->LowerBelow(arg2);
37563     } catch (std::out_of_range& e) {
37564       {
37565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37566       };
37567     } catch (std::exception& e) {
37568       {
37569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37570       };
37571     } catch (Dali::DaliException e) {
37572       {
37573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37574       };
37575     } catch (...) {
37576       {
37577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37578       };
37579     }
37580   }
37581
37582 }
37583
37584
37585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37586   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37587
37588   arg1 = (Dali::Layer *)jarg1;
37589   {
37590     try {
37591       (arg1)->RaiseToTop();
37592     } catch (std::out_of_range& e) {
37593       {
37594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37595       };
37596     } catch (std::exception& e) {
37597       {
37598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37599       };
37600     } catch (Dali::DaliException e) {
37601       {
37602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37603       };
37604     } catch (...) {
37605       {
37606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37607       };
37608     }
37609   }
37610
37611 }
37612
37613
37614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37615   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37616
37617   arg1 = (Dali::Layer *)jarg1;
37618   {
37619     try {
37620       (arg1)->LowerToBottom();
37621     } catch (std::out_of_range& e) {
37622       {
37623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37624       };
37625     } catch (std::exception& e) {
37626       {
37627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37628       };
37629     } catch (Dali::DaliException e) {
37630       {
37631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37632       };
37633     } catch (...) {
37634       {
37635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37636       };
37637     }
37638   }
37639
37640 }
37641
37642
37643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37644   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37645   Dali::Layer arg2 ;
37646   Dali::Layer *argp2 ;
37647
37648   arg1 = (Dali::Layer *)jarg1;
37649   argp2 = (Dali::Layer *)jarg2;
37650   if (!argp2) {
37651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37652     return ;
37653   }
37654   arg2 = *argp2;
37655   {
37656     try {
37657       (arg1)->MoveAbove(arg2);
37658     } catch (std::out_of_range& e) {
37659       {
37660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37661       };
37662     } catch (std::exception& e) {
37663       {
37664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37665       };
37666     } catch (Dali::DaliException e) {
37667       {
37668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37669       };
37670     } catch (...) {
37671       {
37672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37673       };
37674     }
37675   }
37676
37677 }
37678
37679
37680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37681   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37682   Dali::Layer arg2 ;
37683   Dali::Layer *argp2 ;
37684
37685   arg1 = (Dali::Layer *)jarg1;
37686   argp2 = (Dali::Layer *)jarg2;
37687   if (!argp2) {
37688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37689     return ;
37690   }
37691   arg2 = *argp2;
37692   {
37693     try {
37694       (arg1)->MoveBelow(arg2);
37695     } catch (std::out_of_range& e) {
37696       {
37697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37698       };
37699     } catch (std::exception& e) {
37700       {
37701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37702       };
37703     } catch (Dali::DaliException e) {
37704       {
37705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37706       };
37707     } catch (...) {
37708       {
37709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37710       };
37711     }
37712   }
37713
37714 }
37715
37716
37717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37718   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37719   Dali::Layer::Behavior arg2 ;
37720
37721   arg1 = (Dali::Layer *)jarg1;
37722   arg2 = (Dali::Layer::Behavior)jarg2;
37723   {
37724     try {
37725       (arg1)->SetBehavior(arg2);
37726     } catch (std::out_of_range& e) {
37727       {
37728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37729       };
37730     } catch (std::exception& e) {
37731       {
37732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37733       };
37734     } catch (Dali::DaliException e) {
37735       {
37736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37737       };
37738     } catch (...) {
37739       {
37740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37741       };
37742     }
37743   }
37744
37745 }
37746
37747
37748 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37749   int jresult ;
37750   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37751   Dali::Layer::Behavior result;
37752
37753   arg1 = (Dali::Layer *)jarg1;
37754   {
37755     try {
37756       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetBehavior();
37757     } catch (std::out_of_range& e) {
37758       {
37759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37760       };
37761     } catch (std::exception& e) {
37762       {
37763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37764       };
37765     } catch (Dali::DaliException e) {
37766       {
37767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37768       };
37769     } catch (...) {
37770       {
37771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37772       };
37773     }
37774   }
37775
37776   jresult = (int)result;
37777   return jresult;
37778 }
37779
37780
37781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37782   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37783   bool arg2 ;
37784
37785   arg1 = (Dali::Layer *)jarg1;
37786   arg2 = jarg2 ? true : false;
37787   {
37788     try {
37789       (arg1)->SetClipping(arg2);
37790     } catch (std::out_of_range& e) {
37791       {
37792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37793       };
37794     } catch (std::exception& e) {
37795       {
37796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37797       };
37798     } catch (Dali::DaliException e) {
37799       {
37800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37801       };
37802     } catch (...) {
37803       {
37804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37805       };
37806     }
37807   }
37808
37809 }
37810
37811
37812 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37813   unsigned int jresult ;
37814   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37815   bool result;
37816
37817   arg1 = (Dali::Layer *)jarg1;
37818   {
37819     try {
37820       result = (bool)((Dali::Layer const *)arg1)->IsClipping();
37821     } catch (std::out_of_range& e) {
37822       {
37823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37824       };
37825     } catch (std::exception& e) {
37826       {
37827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37828       };
37829     } catch (Dali::DaliException e) {
37830       {
37831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37832       };
37833     } catch (...) {
37834       {
37835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37836       };
37837     }
37838   }
37839
37840   jresult = result;
37841   return jresult;
37842 }
37843
37844
37845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37846   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37847   int arg2 ;
37848   int arg3 ;
37849   int arg4 ;
37850   int arg5 ;
37851
37852   arg1 = (Dali::Layer *)jarg1;
37853   arg2 = (int)jarg2;
37854   arg3 = (int)jarg3;
37855   arg4 = (int)jarg4;
37856   arg5 = (int)jarg5;
37857   {
37858     try {
37859       (arg1)->SetClippingBox(arg2,arg3,arg4,arg5);
37860     } catch (std::out_of_range& e) {
37861       {
37862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37863       };
37864     } catch (std::exception& e) {
37865       {
37866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37867       };
37868     } catch (Dali::DaliException e) {
37869       {
37870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37871       };
37872     } catch (...) {
37873       {
37874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37875       };
37876     }
37877   }
37878
37879 }
37880
37881
37882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37883   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37884   Dali::ClippingBox arg2 ;
37885   Dali::ClippingBox *argp2 ;
37886
37887   arg1 = (Dali::Layer *)jarg1;
37888   argp2 = (Dali::ClippingBox *)jarg2;
37889   if (!argp2) {
37890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37891     return ;
37892   }
37893   arg2 = *argp2;
37894   {
37895     try {
37896       (arg1)->SetClippingBox(arg2);
37897     } catch (std::out_of_range& e) {
37898       {
37899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37900       };
37901     } catch (std::exception& e) {
37902       {
37903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37904       };
37905     } catch (Dali::DaliException e) {
37906       {
37907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37908       };
37909     } catch (...) {
37910       {
37911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37912       };
37913     }
37914   }
37915
37916 }
37917
37918
37919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37920   void * jresult ;
37921   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37922   Dali::ClippingBox result;
37923
37924   arg1 = (Dali::Layer *)jarg1;
37925   {
37926     try {
37927       result = ((Dali::Layer const *)arg1)->GetClippingBox();
37928     } catch (std::out_of_range& e) {
37929       {
37930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37931       };
37932     } catch (std::exception& e) {
37933       {
37934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37935       };
37936     } catch (Dali::DaliException e) {
37937       {
37938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37939       };
37940     } catch (...) {
37941       {
37942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37943       };
37944     }
37945   }
37946
37947   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37948   return jresult;
37949 }
37950
37951
37952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37953   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37954   bool arg2 ;
37955
37956   arg1 = (Dali::Layer *)jarg1;
37957   arg2 = jarg2 ? true : false;
37958   {
37959     try {
37960       (arg1)->SetDepthTestDisabled(arg2);
37961     } catch (std::out_of_range& e) {
37962       {
37963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37964       };
37965     } catch (std::exception& e) {
37966       {
37967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37968       };
37969     } catch (Dali::DaliException e) {
37970       {
37971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37972       };
37973     } catch (...) {
37974       {
37975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37976       };
37977     }
37978   }
37979
37980 }
37981
37982
37983 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37984   unsigned int jresult ;
37985   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37986   bool result;
37987
37988   arg1 = (Dali::Layer *)jarg1;
37989   {
37990     try {
37991       result = (bool)((Dali::Layer const *)arg1)->IsDepthTestDisabled();
37992     } catch (std::out_of_range& e) {
37993       {
37994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37995       };
37996     } catch (std::exception& e) {
37997       {
37998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37999       };
38000     } catch (Dali::DaliException e) {
38001       {
38002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38003       };
38004     } catch (...) {
38005       {
38006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38007       };
38008     }
38009   }
38010
38011   jresult = result;
38012   return jresult;
38013 }
38014
38015
38016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38017   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38018   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38019
38020   arg1 = (Dali::Layer *)jarg1;
38021   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38022   {
38023     try {
38024       (arg1)->SetSortFunction(arg2);
38025     } catch (std::out_of_range& e) {
38026       {
38027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38028       };
38029     } catch (std::exception& e) {
38030       {
38031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38032       };
38033     } catch (Dali::DaliException e) {
38034       {
38035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38036       };
38037     } catch (...) {
38038       {
38039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38040       };
38041     }
38042   }
38043
38044 }
38045
38046
38047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38048   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38049   bool arg2 ;
38050
38051   arg1 = (Dali::Layer *)jarg1;
38052   arg2 = jarg2 ? true : false;
38053   {
38054     try {
38055       (arg1)->SetTouchConsumed(arg2);
38056     } catch (std::out_of_range& e) {
38057       {
38058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38059       };
38060     } catch (std::exception& e) {
38061       {
38062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38063       };
38064     } catch (Dali::DaliException e) {
38065       {
38066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38067       };
38068     } catch (...) {
38069       {
38070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38071       };
38072     }
38073   }
38074
38075 }
38076
38077
38078 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38079   unsigned int jresult ;
38080   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38081   bool result;
38082
38083   arg1 = (Dali::Layer *)jarg1;
38084   {
38085     try {
38086       result = (bool)((Dali::Layer const *)arg1)->IsTouchConsumed();
38087     } catch (std::out_of_range& e) {
38088       {
38089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38090       };
38091     } catch (std::exception& e) {
38092       {
38093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38094       };
38095     } catch (Dali::DaliException e) {
38096       {
38097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38098       };
38099     } catch (...) {
38100       {
38101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38102       };
38103     }
38104   }
38105
38106   jresult = result;
38107   return jresult;
38108 }
38109
38110
38111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38112   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38113   bool arg2 ;
38114
38115   arg1 = (Dali::Layer *)jarg1;
38116   arg2 = jarg2 ? true : false;
38117   {
38118     try {
38119       (arg1)->SetHoverConsumed(arg2);
38120     } catch (std::out_of_range& e) {
38121       {
38122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38123       };
38124     } catch (std::exception& e) {
38125       {
38126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38127       };
38128     } catch (Dali::DaliException e) {
38129       {
38130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38131       };
38132     } catch (...) {
38133       {
38134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38135       };
38136     }
38137   }
38138
38139 }
38140
38141
38142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38143   unsigned int jresult ;
38144   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38145   bool result;
38146
38147   arg1 = (Dali::Layer *)jarg1;
38148   {
38149     try {
38150       result = (bool)((Dali::Layer const *)arg1)->IsHoverConsumed();
38151     } catch (std::out_of_range& e) {
38152       {
38153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38154       };
38155     } catch (std::exception& e) {
38156       {
38157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38158       };
38159     } catch (Dali::DaliException e) {
38160       {
38161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38162       };
38163     } catch (...) {
38164       {
38165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38166       };
38167     }
38168   }
38169
38170   jresult = result;
38171   return jresult;
38172 }
38173
38174
38175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38176   void * jresult ;
38177   Dali::Vector4 *result = 0 ;
38178
38179   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38180   jresult = (void *)result;
38181   return jresult;
38182 }
38183
38184
38185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38186   void * jresult ;
38187   Dali::Vector4 *result = 0 ;
38188
38189   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38190   jresult = (void *)result;
38191   return jresult;
38192 }
38193
38194
38195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38196   void * jresult ;
38197   Dali::Stage *result = 0 ;
38198
38199   {
38200     try {
38201       result = (Dali::Stage *)new Dali::Stage();
38202     } catch (std::out_of_range& e) {
38203       {
38204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38205       };
38206     } catch (std::exception& e) {
38207       {
38208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38209       };
38210     } catch (Dali::DaliException e) {
38211       {
38212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38213       };
38214     } catch (...) {
38215       {
38216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38217       };
38218     }
38219   }
38220
38221   jresult = (void *)result;
38222   return jresult;
38223 }
38224
38225
38226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38227   void * jresult ;
38228   Dali::Stage result;
38229
38230   {
38231     try {
38232       result = Dali::Stage::GetCurrent();
38233     } catch (std::out_of_range& e) {
38234       {
38235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38236       };
38237     } catch (std::exception& e) {
38238       {
38239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38240       };
38241     } catch (Dali::DaliException e) {
38242       {
38243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38244       };
38245     } catch (...) {
38246       {
38247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38248       };
38249     }
38250   }
38251
38252   jresult = new Dali::Stage((const Dali::Stage &)result);
38253   return jresult;
38254 }
38255
38256
38257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38258   unsigned int jresult ;
38259   bool result;
38260
38261   {
38262     try {
38263       result = (bool)Dali::Stage::IsInstalled();
38264     } catch (std::out_of_range& e) {
38265       {
38266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38267       };
38268     } catch (std::exception& e) {
38269       {
38270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38271       };
38272     } catch (Dali::DaliException e) {
38273       {
38274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38275       };
38276     } catch (...) {
38277       {
38278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38279       };
38280     }
38281   }
38282
38283   jresult = result;
38284   return jresult;
38285 }
38286
38287
38288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38289   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38290
38291   arg1 = (Dali::Stage *)jarg1;
38292   {
38293     try {
38294       delete arg1;
38295     } catch (std::out_of_range& e) {
38296       {
38297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38298       };
38299     } catch (std::exception& e) {
38300       {
38301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38302       };
38303     } catch (Dali::DaliException e) {
38304       {
38305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38306       };
38307     } catch (...) {
38308       {
38309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38310       };
38311     }
38312   }
38313
38314 }
38315
38316
38317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38318   void * jresult ;
38319   Dali::Stage *arg1 = 0 ;
38320   Dali::Stage *result = 0 ;
38321
38322   arg1 = (Dali::Stage *)jarg1;
38323   if (!arg1) {
38324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38325     return 0;
38326   }
38327   {
38328     try {
38329       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38330     } catch (std::out_of_range& e) {
38331       {
38332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38333       };
38334     } catch (std::exception& e) {
38335       {
38336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38337       };
38338     } catch (Dali::DaliException e) {
38339       {
38340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38341       };
38342     } catch (...) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38345       };
38346     }
38347   }
38348
38349   jresult = (void *)result;
38350   return jresult;
38351 }
38352
38353
38354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38355   void * jresult ;
38356   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38357   Dali::Stage *arg2 = 0 ;
38358   Dali::Stage *result = 0 ;
38359
38360   arg1 = (Dali::Stage *)jarg1;
38361   arg2 = (Dali::Stage *)jarg2;
38362   if (!arg2) {
38363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38364     return 0;
38365   }
38366   {
38367     try {
38368       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
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_Add(void * jarg1, void * jarg2) {
38394   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38395   Dali::Actor *arg2 = 0 ;
38396
38397   arg1 = (Dali::Stage *)jarg1;
38398   arg2 = (Dali::Actor *)jarg2;
38399   if (!arg2) {
38400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38401     return ;
38402   }
38403   {
38404     try {
38405       (arg1)->Add(*arg2);
38406     } catch (std::out_of_range& e) {
38407       {
38408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38409       };
38410     } catch (std::exception& e) {
38411       {
38412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38413       };
38414     } catch (Dali::DaliException e) {
38415       {
38416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38417       };
38418     } catch (...) {
38419       {
38420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38421       };
38422     }
38423   }
38424
38425 }
38426
38427
38428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38429   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38430   Dali::Actor *arg2 = 0 ;
38431
38432   arg1 = (Dali::Stage *)jarg1;
38433   arg2 = (Dali::Actor *)jarg2;
38434   if (!arg2) {
38435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38436     return ;
38437   }
38438   {
38439     try {
38440       (arg1)->Remove(*arg2);
38441     } catch (std::out_of_range& e) {
38442       {
38443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38444       };
38445     } catch (std::exception& e) {
38446       {
38447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38448       };
38449     } catch (Dali::DaliException e) {
38450       {
38451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38452       };
38453     } catch (...) {
38454       {
38455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38456       };
38457     }
38458   }
38459
38460 }
38461
38462
38463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38464   void * jresult ;
38465   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38466   Dali::Vector2 result;
38467
38468   arg1 = (Dali::Stage *)jarg1;
38469   {
38470     try {
38471       result = ((Dali::Stage const *)arg1)->GetSize();
38472     } catch (std::out_of_range& e) {
38473       {
38474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38475       };
38476     } catch (std::exception& e) {
38477       {
38478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38479       };
38480     } catch (Dali::DaliException e) {
38481       {
38482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38483       };
38484     } catch (...) {
38485       {
38486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38487       };
38488     }
38489   }
38490
38491   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38492   return jresult;
38493 }
38494
38495
38496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38497   void * jresult ;
38498   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38499   Dali::RenderTaskList result;
38500
38501   arg1 = (Dali::Stage *)jarg1;
38502   {
38503     try {
38504       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38505     } catch (std::out_of_range& e) {
38506       {
38507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38508       };
38509     } catch (std::exception& e) {
38510       {
38511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38512       };
38513     } catch (Dali::DaliException e) {
38514       {
38515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38516       };
38517     } catch (...) {
38518       {
38519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38520       };
38521     }
38522   }
38523
38524   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38525   return jresult;
38526 }
38527
38528
38529 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38530   unsigned int jresult ;
38531   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38532   unsigned int result;
38533
38534   arg1 = (Dali::Stage *)jarg1;
38535   {
38536     try {
38537       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38538     } catch (std::out_of_range& e) {
38539       {
38540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38541       };
38542     } catch (std::exception& e) {
38543       {
38544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38545       };
38546     } catch (Dali::DaliException e) {
38547       {
38548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38549       };
38550     } catch (...) {
38551       {
38552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38553       };
38554     }
38555   }
38556
38557   jresult = result;
38558   return jresult;
38559 }
38560
38561
38562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38563   void * jresult ;
38564   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38565   unsigned int arg2 ;
38566   Dali::Layer result;
38567
38568   arg1 = (Dali::Stage *)jarg1;
38569   arg2 = (unsigned int)jarg2;
38570   {
38571     try {
38572       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38573     } catch (std::out_of_range& e) {
38574       {
38575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38576       };
38577     } catch (std::exception& e) {
38578       {
38579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38580       };
38581     } catch (Dali::DaliException e) {
38582       {
38583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38584       };
38585     } catch (...) {
38586       {
38587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38588       };
38589     }
38590   }
38591
38592   jresult = new Dali::Layer((const Dali::Layer &)result);
38593   return jresult;
38594 }
38595
38596
38597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38598   void * jresult ;
38599   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38600   Dali::Layer result;
38601
38602   arg1 = (Dali::Stage *)jarg1;
38603   {
38604     try {
38605       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38606     } catch (std::out_of_range& e) {
38607       {
38608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38609       };
38610     } catch (std::exception& e) {
38611       {
38612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38613       };
38614     } catch (Dali::DaliException e) {
38615       {
38616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38617       };
38618     } catch (...) {
38619       {
38620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38621       };
38622     }
38623   }
38624
38625   jresult = new Dali::Layer((const Dali::Layer &)result);
38626   return jresult;
38627 }
38628
38629
38630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38631   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38632   Dali::Vector4 arg2 ;
38633   Dali::Vector4 *argp2 ;
38634
38635   arg1 = (Dali::Stage *)jarg1;
38636   argp2 = (Dali::Vector4 *)jarg2;
38637   if (!argp2) {
38638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38639     return ;
38640   }
38641   arg2 = *argp2;
38642   {
38643     try {
38644       (arg1)->SetBackgroundColor(arg2);
38645     } catch (std::out_of_range& e) {
38646       {
38647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38648       };
38649     } catch (std::exception& e) {
38650       {
38651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38652       };
38653     } catch (Dali::DaliException e) {
38654       {
38655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38656       };
38657     } catch (...) {
38658       {
38659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38660       };
38661     }
38662   }
38663
38664 }
38665
38666
38667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38668   void * jresult ;
38669   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38670   Dali::Vector4 result;
38671
38672   arg1 = (Dali::Stage *)jarg1;
38673   {
38674     try {
38675       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38676     } catch (std::out_of_range& e) {
38677       {
38678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38679       };
38680     } catch (std::exception& e) {
38681       {
38682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38683       };
38684     } catch (Dali::DaliException e) {
38685       {
38686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38687       };
38688     } catch (...) {
38689       {
38690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38691       };
38692     }
38693   }
38694
38695   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38696   return jresult;
38697 }
38698
38699
38700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38701   void * jresult ;
38702   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38703   Dali::Vector2 result;
38704
38705   arg1 = (Dali::Stage *)jarg1;
38706   {
38707     try {
38708       result = ((Dali::Stage const *)arg1)->GetDpi();
38709     } catch (std::out_of_range& e) {
38710       {
38711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38712       };
38713     } catch (std::exception& e) {
38714       {
38715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38716       };
38717     } catch (Dali::DaliException e) {
38718       {
38719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38720       };
38721     } catch (...) {
38722       {
38723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38724       };
38725     }
38726   }
38727
38728   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38729   return jresult;
38730 }
38731
38732
38733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38734   void * jresult ;
38735   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38736   Dali::ObjectRegistry result;
38737
38738   arg1 = (Dali::Stage *)jarg1;
38739   {
38740     try {
38741       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38742     } catch (std::out_of_range& e) {
38743       {
38744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38745       };
38746     } catch (std::exception& e) {
38747       {
38748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38749       };
38750     } catch (Dali::DaliException e) {
38751       {
38752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38753       };
38754     } catch (...) {
38755       {
38756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38757       };
38758     }
38759   }
38760
38761   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38762   return jresult;
38763 }
38764
38765
38766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38767   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38768   float arg2 ;
38769
38770   arg1 = (Dali::Stage *)jarg1;
38771   arg2 = (float)jarg2;
38772   {
38773     try {
38774       (arg1)->KeepRendering(arg2);
38775     } catch (std::out_of_range& e) {
38776       {
38777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38778       };
38779     } catch (std::exception& e) {
38780       {
38781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38782       };
38783     } catch (Dali::DaliException e) {
38784       {
38785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38786       };
38787     } catch (...) {
38788       {
38789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38790       };
38791     }
38792   }
38793
38794 }
38795
38796
38797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38798   void * jresult ;
38799   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38800   Dali::Stage::KeyEventSignalType *result = 0 ;
38801
38802   arg1 = (Dali::Stage *)jarg1;
38803   {
38804     try {
38805       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38806     } catch (std::out_of_range& e) {
38807       {
38808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38809       };
38810     } catch (std::exception& e) {
38811       {
38812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38813       };
38814     } catch (Dali::DaliException e) {
38815       {
38816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38817       };
38818     } catch (...) {
38819       {
38820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38821       };
38822     }
38823   }
38824
38825   jresult = (void *)result;
38826   return jresult;
38827 }
38828
38829
38830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38831   void * jresult ;
38832   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38833   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38834
38835   arg1 = (Dali::Stage *)jarg1;
38836   {
38837     try {
38838       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38839     } catch (std::out_of_range& e) {
38840       {
38841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38842       };
38843     } catch (std::exception& e) {
38844       {
38845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38846       };
38847     } catch (Dali::DaliException e) {
38848       {
38849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38850       };
38851     } catch (...) {
38852       {
38853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38854       };
38855     }
38856   }
38857
38858   jresult = (void *)result;
38859   return jresult;
38860 }
38861
38862
38863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38864   void * jresult ;
38865   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38866   Dali::Stage::TouchSignalType *result = 0 ;
38867
38868   arg1 = (Dali::Stage *)jarg1;
38869   {
38870     try {
38871       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38872     } catch (std::out_of_range& e) {
38873       {
38874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38875       };
38876     } catch (std::exception& e) {
38877       {
38878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38879       };
38880     } catch (Dali::DaliException e) {
38881       {
38882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38883       };
38884     } catch (...) {
38885       {
38886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38887       };
38888     }
38889   }
38890
38891   jresult = (void *)result;
38892   return jresult;
38893 }
38894
38895
38896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38897   void * jresult ;
38898   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38899   Dali::Stage::WheelEventSignalType *result = 0 ;
38900
38901   arg1 = (Dali::Stage *)jarg1;
38902   {
38903     try {
38904       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38905     } catch (std::out_of_range& e) {
38906       {
38907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38908       };
38909     } catch (std::exception& e) {
38910       {
38911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38912       };
38913     } catch (Dali::DaliException e) {
38914       {
38915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38916       };
38917     } catch (...) {
38918       {
38919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38920       };
38921     }
38922   }
38923
38924   jresult = (void *)result;
38925   return jresult;
38926 }
38927
38928
38929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38930   void * jresult ;
38931   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38932   Dali::Stage::ContextStatusSignal *result = 0 ;
38933
38934   arg1 = (Dali::Stage *)jarg1;
38935   {
38936     try {
38937       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38938     } catch (std::out_of_range& e) {
38939       {
38940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38941       };
38942     } catch (std::exception& e) {
38943       {
38944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38945       };
38946     } catch (Dali::DaliException e) {
38947       {
38948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38949       };
38950     } catch (...) {
38951       {
38952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38953       };
38954     }
38955   }
38956
38957   jresult = (void *)result;
38958   return jresult;
38959 }
38960
38961
38962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38963   void * jresult ;
38964   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38965   Dali::Stage::ContextStatusSignal *result = 0 ;
38966
38967   arg1 = (Dali::Stage *)jarg1;
38968   {
38969     try {
38970       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38971     } catch (std::out_of_range& e) {
38972       {
38973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38974       };
38975     } catch (std::exception& e) {
38976       {
38977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38978       };
38979     } catch (Dali::DaliException e) {
38980       {
38981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38982       };
38983     } catch (...) {
38984       {
38985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38986       };
38987     }
38988   }
38989
38990   jresult = (void *)result;
38991   return jresult;
38992 }
38993
38994
38995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38996   void * jresult ;
38997   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38998   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38999
39000   arg1 = (Dali::Stage *)jarg1;
39001   {
39002     try {
39003       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39004     } catch (std::out_of_range& e) {
39005       {
39006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39007       };
39008     } catch (std::exception& e) {
39009       {
39010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39011       };
39012     } catch (Dali::DaliException e) {
39013       {
39014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39015       };
39016     } catch (...) {
39017       {
39018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39019       };
39020     }
39021   }
39022
39023   jresult = (void *)result;
39024   return jresult;
39025 }
39026
39027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39028   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39029   Dali::DevelStage::Rendering arg2 ;
39030
39031   arg1 = (Dali::Stage *)jarg1;
39032   arg2 = (Dali::DevelStage::Rendering)jarg2;
39033   {
39034     try {
39035       DevelStage::SetRenderingBehavior(*arg1,arg2);
39036     } catch (std::out_of_range& e) {
39037       {
39038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39039       };
39040     } catch (std::exception& e) {
39041       {
39042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39043       };
39044     } catch (Dali::DaliException e) {
39045       {
39046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39047       };
39048     } catch (...) {
39049       {
39050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39051       };
39052     }
39053   }
39054
39055 }
39056
39057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39058
39059   int jresult ;
39060   int result ;
39061   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39062
39063   arg1 = (Dali::Stage *)jarg1;
39064   {
39065     try {
39066       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39067     } catch (std::out_of_range& e) {
39068       {
39069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39070       };
39071     } catch (std::exception& e) {
39072       {
39073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39074       };
39075     } catch (Dali::DaliException e) {
39076       {
39077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39078       };
39079     } catch (...) {
39080       {
39081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39082       };
39083     }
39084   }
39085
39086   jresult = result;
39087   return jresult;
39088 }
39089
39090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39091   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39092
39093   arg1 = (Dali::RelayoutContainer *)jarg1;
39094   {
39095     try {
39096       delete arg1;
39097     } catch (std::out_of_range& e) {
39098       {
39099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39100       };
39101     } catch (std::exception& e) {
39102       {
39103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39104       };
39105     } catch (Dali::DaliException e) {
39106       {
39107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39108       };
39109     } catch (...) {
39110       {
39111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39112       };
39113     }
39114   }
39115
39116 }
39117
39118
39119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39120   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39121   Dali::Actor *arg2 = 0 ;
39122   Dali::Vector2 *arg3 = 0 ;
39123
39124   arg1 = (Dali::RelayoutContainer *)jarg1;
39125   arg2 = (Dali::Actor *)jarg2;
39126   if (!arg2) {
39127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39128     return ;
39129   }
39130   arg3 = (Dali::Vector2 *)jarg3;
39131   if (!arg3) {
39132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39133     return ;
39134   }
39135   {
39136     try {
39137       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39138     } catch (std::out_of_range& e) {
39139       {
39140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39141       };
39142     } catch (std::exception& e) {
39143       {
39144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39145       };
39146     } catch (Dali::DaliException e) {
39147       {
39148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39149       };
39150     } catch (...) {
39151       {
39152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39153       };
39154     }
39155   }
39156
39157 }
39158
39159
39160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39161   void * jresult ;
39162   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39163   Dali::CustomActor result;
39164
39165   arg1 = (Dali::CustomActorImpl *)jarg1;
39166   {
39167     try {
39168       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39169     } catch (std::out_of_range& e) {
39170       {
39171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39172       };
39173     } catch (std::exception& e) {
39174       {
39175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39176       };
39177     } catch (Dali::DaliException e) {
39178       {
39179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39180       };
39181     } catch (...) {
39182       {
39183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39184       };
39185     }
39186   }
39187
39188   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39189   return jresult;
39190 }
39191
39192
39193 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39194   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39195   int arg2 ;
39196
39197   arg1 = (Dali::CustomActorImpl *)jarg1;
39198   arg2 = (int)jarg2;
39199   {
39200     try {
39201       (arg1)->OnStageConnection(arg2);
39202     } catch (std::out_of_range& e) {
39203       {
39204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39205       };
39206     } catch (std::exception& e) {
39207       {
39208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39209       };
39210     } catch (Dali::DaliException e) {
39211       {
39212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39213       };
39214     } catch (...) {
39215       {
39216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39217       };
39218     }
39219   }
39220
39221 }
39222
39223
39224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39225   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39226
39227   arg1 = (Dali::CustomActorImpl *)jarg1;
39228   {
39229     try {
39230       (arg1)->OnStageDisconnection();
39231     } catch (std::out_of_range& e) {
39232       {
39233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39234       };
39235     } catch (std::exception& e) {
39236       {
39237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39238       };
39239     } catch (Dali::DaliException e) {
39240       {
39241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39242       };
39243     } catch (...) {
39244       {
39245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39246       };
39247     }
39248   }
39249
39250 }
39251
39252
39253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39254   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39255   Dali::Actor *arg2 = 0 ;
39256
39257   arg1 = (Dali::CustomActorImpl *)jarg1;
39258   arg2 = (Dali::Actor *)jarg2;
39259   if (!arg2) {
39260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39261     return ;
39262   }
39263   {
39264     try {
39265       (arg1)->OnChildAdd(*arg2);
39266     } catch (std::out_of_range& e) {
39267       {
39268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39269       };
39270     } catch (std::exception& e) {
39271       {
39272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39273       };
39274     } catch (Dali::DaliException e) {
39275       {
39276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39277       };
39278     } catch (...) {
39279       {
39280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39281       };
39282     }
39283   }
39284
39285 }
39286
39287
39288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39289   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39290   Dali::Actor *arg2 = 0 ;
39291
39292   arg1 = (Dali::CustomActorImpl *)jarg1;
39293   arg2 = (Dali::Actor *)jarg2;
39294   if (!arg2) {
39295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39296     return ;
39297   }
39298   {
39299     try {
39300       (arg1)->OnChildRemove(*arg2);
39301     } catch (std::out_of_range& e) {
39302       {
39303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39304       };
39305     } catch (std::exception& e) {
39306       {
39307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39308       };
39309     } catch (Dali::DaliException e) {
39310       {
39311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39312       };
39313     } catch (...) {
39314       {
39315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39316       };
39317     }
39318   }
39319
39320 }
39321
39322
39323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39324   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39325   Dali::Property::Index arg2 ;
39326   Dali::Property::Value arg3 ;
39327   Dali::Property::Value *argp3 ;
39328
39329   arg1 = (Dali::CustomActorImpl *)jarg1;
39330   arg2 = (Dali::Property::Index)jarg2;
39331   argp3 = (Dali::Property::Value *)jarg3;
39332   if (!argp3) {
39333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39334     return ;
39335   }
39336   arg3 = *argp3;
39337   {
39338     try {
39339       (arg1)->OnPropertySet(arg2,arg3);
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_OnSizeSet(void * jarg1, void * jarg2) {
39363   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39364   Dali::Vector3 *arg2 = 0 ;
39365
39366   arg1 = (Dali::CustomActorImpl *)jarg1;
39367   arg2 = (Dali::Vector3 *)jarg2;
39368   if (!arg2) {
39369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39370     return ;
39371   }
39372   {
39373     try {
39374       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39375     } catch (std::out_of_range& e) {
39376       {
39377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39378       };
39379     } catch (std::exception& e) {
39380       {
39381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39382       };
39383     } catch (Dali::DaliException e) {
39384       {
39385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39386       };
39387     } catch (...) {
39388       {
39389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39390       };
39391     }
39392   }
39393
39394 }
39395
39396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39397   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39398   Dali::Animation *arg2 = 0 ;
39399   Dali::Vector3 *arg3 = 0 ;
39400
39401   arg1 = (Dali::CustomActorImpl *)jarg1;
39402   arg2 = (Dali::Animation *)jarg2;
39403   if (!arg2) {
39404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39405     return ;
39406   }
39407   arg3 = (Dali::Vector3 *)jarg3;
39408   if (!arg3) {
39409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39410     return ;
39411   }
39412   {
39413     try {
39414       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39415     } catch (std::out_of_range& e) {
39416       {
39417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39418       };
39419     } catch (std::exception& e) {
39420       {
39421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39422       };
39423     } catch (Dali::DaliException e) {
39424       {
39425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39426       };
39427     } catch (...) {
39428       {
39429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39430       };
39431     }
39432   }
39433
39434 }
39435
39436
39437 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39438   unsigned int jresult ;
39439   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39440   Dali::TouchEvent *arg2 = 0 ;
39441   bool result;
39442
39443   arg1 = (Dali::CustomActorImpl *)jarg1;
39444   arg2 = (Dali::TouchEvent *)jarg2;
39445   if (!arg2) {
39446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39447     return 0;
39448   }
39449   {
39450     try {
39451       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39452     } catch (std::out_of_range& e) {
39453       {
39454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39455       };
39456     } catch (std::exception& e) {
39457       {
39458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39459       };
39460     } catch (Dali::DaliException e) {
39461       {
39462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39463       };
39464     } catch (...) {
39465       {
39466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39467       };
39468     }
39469   }
39470
39471   jresult = result;
39472   return jresult;
39473 }
39474
39475
39476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39477   unsigned int jresult ;
39478   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39479   Dali::HoverEvent *arg2 = 0 ;
39480   bool result;
39481
39482   arg1 = (Dali::CustomActorImpl *)jarg1;
39483   arg2 = (Dali::HoverEvent *)jarg2;
39484   if (!arg2) {
39485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39486     return 0;
39487   }
39488   {
39489     try {
39490       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent 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_OnKeyEvent(void * jarg1, void * jarg2) {
39516   unsigned int jresult ;
39517   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39518   Dali::KeyEvent *arg2 = 0 ;
39519   bool result;
39520
39521   arg1 = (Dali::CustomActorImpl *)jarg1;
39522   arg2 = (Dali::KeyEvent *)jarg2;
39523   if (!arg2) {
39524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39525     return 0;
39526   }
39527   {
39528     try {
39529       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent 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_OnWheelEvent(void * jarg1, void * jarg2) {
39555   unsigned int jresult ;
39556   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39557   Dali::WheelEvent *arg2 = 0 ;
39558   bool result;
39559
39560   arg1 = (Dali::CustomActorImpl *)jarg1;
39561   arg2 = (Dali::WheelEvent *)jarg2;
39562   if (!arg2) {
39563     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39564     return 0;
39565   }
39566   {
39567     try {
39568       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent 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 void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39594   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39595   Dali::Vector2 *arg2 = 0 ;
39596   Dali::RelayoutContainer *arg3 = 0 ;
39597
39598   arg1 = (Dali::CustomActorImpl *)jarg1;
39599   arg2 = (Dali::Vector2 *)jarg2;
39600   if (!arg2) {
39601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39602     return ;
39603   }
39604   arg3 = (Dali::RelayoutContainer *)jarg3;
39605   if (!arg3) {
39606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39607     return ;
39608   }
39609   {
39610     try {
39611       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39612     } catch (std::out_of_range& e) {
39613       {
39614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39615       };
39616     } catch (std::exception& e) {
39617       {
39618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39619       };
39620     } catch (Dali::DaliException e) {
39621       {
39622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39623       };
39624     } catch (...) {
39625       {
39626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39627       };
39628     }
39629   }
39630
39631 }
39632
39633
39634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39635   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39636   Dali::ResizePolicy::Type arg2 ;
39637   Dali::Dimension::Type arg3 ;
39638
39639   arg1 = (Dali::CustomActorImpl *)jarg1;
39640   arg2 = (Dali::ResizePolicy::Type)jarg2;
39641   arg3 = (Dali::Dimension::Type)jarg3;
39642   {
39643     try {
39644       (arg1)->OnSetResizePolicy(arg2,arg3);
39645     } catch (std::out_of_range& e) {
39646       {
39647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39648       };
39649     } catch (std::exception& e) {
39650       {
39651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39652       };
39653     } catch (Dali::DaliException e) {
39654       {
39655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39656       };
39657     } catch (...) {
39658       {
39659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39660       };
39661     }
39662   }
39663
39664 }
39665
39666
39667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39668   void * jresult ;
39669   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39670   Dali::Vector3 result;
39671
39672   arg1 = (Dali::CustomActorImpl *)jarg1;
39673   {
39674     try {
39675       result = (arg1)->GetNaturalSize();
39676     } catch (std::out_of_range& e) {
39677       {
39678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39679       };
39680     } catch (std::exception& e) {
39681       {
39682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39683       };
39684     } catch (Dali::DaliException e) {
39685       {
39686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39687       };
39688     } catch (...) {
39689       {
39690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39691       };
39692     }
39693   }
39694
39695   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39696   return jresult;
39697 }
39698
39699
39700 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39701   float jresult ;
39702   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39703   Dali::Actor *arg2 = 0 ;
39704   Dali::Dimension::Type arg3 ;
39705   float result;
39706
39707   arg1 = (Dali::CustomActorImpl *)jarg1;
39708   arg2 = (Dali::Actor *)jarg2;
39709   if (!arg2) {
39710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39711     return 0;
39712   }
39713   arg3 = (Dali::Dimension::Type)jarg3;
39714   {
39715     try {
39716       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39717     } catch (std::out_of_range& e) {
39718       {
39719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39720       };
39721     } catch (std::exception& e) {
39722       {
39723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39724       };
39725     } catch (Dali::DaliException e) {
39726       {
39727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39728       };
39729     } catch (...) {
39730       {
39731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39732       };
39733     }
39734   }
39735
39736   jresult = result;
39737   return jresult;
39738 }
39739
39740
39741 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39742   float jresult ;
39743   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39744   float arg2 ;
39745   float result;
39746
39747   arg1 = (Dali::CustomActorImpl *)jarg1;
39748   arg2 = (float)jarg2;
39749   {
39750     try {
39751       result = (float)(arg1)->GetHeightForWidth(arg2);
39752     } catch (std::out_of_range& e) {
39753       {
39754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39755       };
39756     } catch (std::exception& e) {
39757       {
39758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39759       };
39760     } catch (Dali::DaliException e) {
39761       {
39762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39763       };
39764     } catch (...) {
39765       {
39766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39767       };
39768     }
39769   }
39770
39771   jresult = result;
39772   return jresult;
39773 }
39774
39775
39776 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39777   float jresult ;
39778   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39779   float arg2 ;
39780   float result;
39781
39782   arg1 = (Dali::CustomActorImpl *)jarg1;
39783   arg2 = (float)jarg2;
39784   {
39785     try {
39786       result = (float)(arg1)->GetWidthForHeight(arg2);
39787     } catch (std::out_of_range& e) {
39788       {
39789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39790       };
39791     } catch (std::exception& e) {
39792       {
39793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39794       };
39795     } catch (Dali::DaliException e) {
39796       {
39797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39798       };
39799     } catch (...) {
39800       {
39801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39802       };
39803     }
39804   }
39805
39806   jresult = result;
39807   return jresult;
39808 }
39809
39810
39811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39812   unsigned int jresult ;
39813   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39814   Dali::Dimension::Type arg2 ;
39815   bool result;
39816
39817   arg1 = (Dali::CustomActorImpl *)jarg1;
39818   arg2 = (Dali::Dimension::Type)jarg2;
39819   {
39820     try {
39821       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39822     } catch (std::out_of_range& e) {
39823       {
39824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39825       };
39826     } catch (std::exception& e) {
39827       {
39828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39829       };
39830     } catch (Dali::DaliException e) {
39831       {
39832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39833       };
39834     } catch (...) {
39835       {
39836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39837       };
39838     }
39839   }
39840
39841   jresult = result;
39842   return jresult;
39843 }
39844
39845
39846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39847   unsigned int jresult ;
39848   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39849   bool result;
39850
39851   arg1 = (Dali::CustomActorImpl *)jarg1;
39852   {
39853     try {
39854       result = (bool)(arg1)->RelayoutDependentOnChildren();
39855     } catch (std::out_of_range& e) {
39856       {
39857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39858       };
39859     } catch (std::exception& e) {
39860       {
39861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39862       };
39863     } catch (Dali::DaliException e) {
39864       {
39865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39866       };
39867     } catch (...) {
39868       {
39869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39870       };
39871     }
39872   }
39873
39874   jresult = result;
39875   return jresult;
39876 }
39877
39878
39879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39880   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39881   Dali::Dimension::Type arg2 ;
39882
39883   arg1 = (Dali::CustomActorImpl *)jarg1;
39884   arg2 = (Dali::Dimension::Type)jarg2;
39885   {
39886     try {
39887       (arg1)->OnCalculateRelayoutSize(arg2);
39888     } catch (std::out_of_range& e) {
39889       {
39890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39891       };
39892     } catch (std::exception& e) {
39893       {
39894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39895       };
39896     } catch (Dali::DaliException e) {
39897       {
39898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39899       };
39900     } catch (...) {
39901       {
39902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39903       };
39904     }
39905   }
39906
39907 }
39908
39909
39910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39911   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39912   float arg2 ;
39913   Dali::Dimension::Type arg3 ;
39914
39915   arg1 = (Dali::CustomActorImpl *)jarg1;
39916   arg2 = (float)jarg2;
39917   arg3 = (Dali::Dimension::Type)jarg3;
39918   {
39919     try {
39920       (arg1)->OnLayoutNegotiated(arg2,arg3);
39921     } catch (std::out_of_range& e) {
39922       {
39923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39924       };
39925     } catch (std::exception& e) {
39926       {
39927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39928       };
39929     } catch (Dali::DaliException e) {
39930       {
39931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39932       };
39933     } catch (...) {
39934       {
39935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39936       };
39937     }
39938   }
39939
39940 }
39941
39942
39943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39944   unsigned int jresult ;
39945   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39946   bool result;
39947
39948   arg1 = (Dali::CustomActorImpl *)jarg1;
39949   {
39950     try {
39951       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39952     } catch (std::out_of_range& e) {
39953       {
39954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39955       };
39956     } catch (std::exception& e) {
39957       {
39958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39959       };
39960     } catch (Dali::DaliException e) {
39961       {
39962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39963       };
39964     } catch (...) {
39965       {
39966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39967       };
39968     }
39969   }
39970
39971   jresult = result;
39972   return jresult;
39973 }
39974
39975
39976 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39977   unsigned int jresult ;
39978   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39979   bool result;
39980
39981   arg1 = (Dali::CustomActorImpl *)jarg1;
39982   {
39983     try {
39984       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39985     } catch (std::out_of_range& e) {
39986       {
39987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39988       };
39989     } catch (std::exception& e) {
39990       {
39991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39992       };
39993     } catch (Dali::DaliException e) {
39994       {
39995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39996       };
39997     } catch (...) {
39998       {
39999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40000       };
40001     }
40002   }
40003
40004   jresult = result;
40005   return jresult;
40006 }
40007
40008
40009 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40010   unsigned int jresult ;
40011   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40012   bool result;
40013
40014   arg1 = (Dali::CustomActorImpl *)jarg1;
40015   {
40016     try {
40017       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40018     } catch (std::out_of_range& e) {
40019       {
40020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40021       };
40022     } catch (std::exception& e) {
40023       {
40024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40025       };
40026     } catch (Dali::DaliException e) {
40027       {
40028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40029       };
40030     } catch (...) {
40031       {
40032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40033       };
40034     }
40035   }
40036
40037   jresult = result;
40038   return jresult;
40039 }
40040
40041
40042 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40043   unsigned int jresult ;
40044   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40045   bool result;
40046
40047   arg1 = (Dali::CustomActorImpl *)jarg1;
40048   {
40049     try {
40050       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40051     } catch (std::out_of_range& e) {
40052       {
40053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40054       };
40055     } catch (std::exception& e) {
40056       {
40057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40058       };
40059     } catch (Dali::DaliException e) {
40060       {
40061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40062       };
40063     } catch (...) {
40064       {
40065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40066       };
40067     }
40068   }
40069
40070   jresult = result;
40071   return jresult;
40072 }
40073
40074
40075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40076   void * jresult ;
40077   Dali::CustomActor *result = 0 ;
40078
40079   {
40080     try {
40081       result = (Dali::CustomActor *)new Dali::CustomActor();
40082     } catch (std::out_of_range& e) {
40083       {
40084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40085       };
40086     } catch (std::exception& e) {
40087       {
40088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40089       };
40090     } catch (Dali::DaliException e) {
40091       {
40092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40093       };
40094     } catch (...) {
40095       {
40096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40097       };
40098     }
40099   }
40100
40101   jresult = (void *)result;
40102   return jresult;
40103 }
40104
40105
40106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40107   void * jresult ;
40108   Dali::BaseHandle arg1 ;
40109   Dali::BaseHandle *argp1 ;
40110   Dali::CustomActor result;
40111
40112   argp1 = (Dali::BaseHandle *)jarg1;
40113   if (!argp1) {
40114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40115     return 0;
40116   }
40117   arg1 = *argp1;
40118   {
40119     try {
40120       result = Dali::CustomActor::DownCast(arg1);
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 = new Dali::CustomActor((const Dali::CustomActor &)result);
40141   return jresult;
40142 }
40143
40144
40145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40146   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40147
40148   arg1 = (Dali::CustomActor *)jarg1;
40149   {
40150     try {
40151       delete arg1;
40152     } catch (std::out_of_range& e) {
40153       {
40154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40155       };
40156     } catch (std::exception& e) {
40157       {
40158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40159       };
40160     } catch (Dali::DaliException e) {
40161       {
40162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40163       };
40164     } catch (...) {
40165       {
40166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40167       };
40168     }
40169   }
40170
40171 }
40172
40173
40174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40175   void * jresult ;
40176   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40177   Dali::CustomActorImpl *result = 0 ;
40178
40179   arg1 = (Dali::CustomActor *)jarg1;
40180   {
40181     try {
40182       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40183     } catch (std::out_of_range& e) {
40184       {
40185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40186       };
40187     } catch (std::exception& e) {
40188       {
40189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40190       };
40191     } catch (Dali::DaliException e) {
40192       {
40193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40194       };
40195     } catch (...) {
40196       {
40197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40198       };
40199     }
40200   }
40201
40202   jresult = (void *)result;
40203   return jresult;
40204 }
40205
40206
40207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40208   void * jresult ;
40209   Dali::CustomActorImpl *arg1 = 0 ;
40210   Dali::CustomActor *result = 0 ;
40211
40212   arg1 = (Dali::CustomActorImpl *)jarg1;
40213   if (!arg1) {
40214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40215     return 0;
40216   }
40217   {
40218     try {
40219       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40220     } catch (std::out_of_range& e) {
40221       {
40222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40223       };
40224     } catch (std::exception& e) {
40225       {
40226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40227       };
40228     } catch (Dali::DaliException e) {
40229       {
40230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40231       };
40232     } catch (...) {
40233       {
40234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40235       };
40236     }
40237   }
40238
40239   jresult = (void *)result;
40240   return jresult;
40241 }
40242
40243
40244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40245   void * jresult ;
40246   Dali::CustomActor *arg1 = 0 ;
40247   Dali::CustomActor *result = 0 ;
40248
40249   arg1 = (Dali::CustomActor *)jarg1;
40250   if (!arg1) {
40251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40252     return 0;
40253   }
40254   {
40255     try {
40256       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40257     } catch (std::out_of_range& e) {
40258       {
40259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40260       };
40261     } catch (std::exception& e) {
40262       {
40263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40264       };
40265     } catch (Dali::DaliException e) {
40266       {
40267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40268       };
40269     } catch (...) {
40270       {
40271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40272       };
40273     }
40274   }
40275
40276   jresult = (void *)result;
40277   return jresult;
40278 }
40279
40280
40281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40282   void * jresult ;
40283   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40284   Dali::CustomActor *arg2 = 0 ;
40285   Dali::CustomActor *result = 0 ;
40286
40287   arg1 = (Dali::CustomActor *)jarg1;
40288   arg2 = (Dali::CustomActor *)jarg2;
40289   if (!arg2) {
40290     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40291     return 0;
40292   }
40293   {
40294     try {
40295       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
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 int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40321   int jresult ;
40322   int result;
40323
40324   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40325   jresult = (int)result;
40326   return jresult;
40327 }
40328
40329
40330 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40331   int jresult ;
40332   int result;
40333
40334   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40335   jresult = (int)result;
40336   return jresult;
40337 }
40338
40339
40340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40341   int jresult ;
40342   int result;
40343
40344   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40345   jresult = (int)result;
40346   return jresult;
40347 }
40348
40349
40350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40351   int jresult ;
40352   int result;
40353
40354   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40355   jresult = (int)result;
40356   return jresult;
40357 }
40358
40359
40360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40361   int jresult ;
40362   int result;
40363
40364   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40365   jresult = (int)result;
40366   return jresult;
40367 }
40368
40369
40370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40371   int jresult ;
40372   int result;
40373
40374   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40375   jresult = (int)result;
40376   return jresult;
40377 }
40378
40379
40380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40381   int jresult ;
40382   int result;
40383
40384   result = (int)Dali::PanGestureDetector::Property::PANNING;
40385   jresult = (int)result;
40386   return jresult;
40387 }
40388
40389
40390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40391   void * jresult ;
40392   Dali::PanGestureDetector::Property *result = 0 ;
40393
40394   {
40395     try {
40396       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40397     } catch (std::out_of_range& e) {
40398       {
40399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40400       };
40401     } catch (std::exception& e) {
40402       {
40403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40404       };
40405     } catch (Dali::DaliException e) {
40406       {
40407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40408       };
40409     } catch (...) {
40410       {
40411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40412       };
40413     }
40414   }
40415
40416   jresult = (void *)result;
40417   return jresult;
40418 }
40419
40420
40421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40422   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40423
40424   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40425   {
40426     try {
40427       delete arg1;
40428     } catch (std::out_of_range& e) {
40429       {
40430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40431       };
40432     } catch (std::exception& e) {
40433       {
40434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40435       };
40436     } catch (Dali::DaliException e) {
40437       {
40438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40439       };
40440     } catch (...) {
40441       {
40442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40443       };
40444     }
40445   }
40446
40447 }
40448
40449
40450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40451   void * jresult ;
40452   Dali::Radian *result = 0 ;
40453
40454   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40455   jresult = (void *)result;
40456   return jresult;
40457 }
40458
40459
40460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40461   void * jresult ;
40462   Dali::Radian *result = 0 ;
40463
40464   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40465   jresult = (void *)result;
40466   return jresult;
40467 }
40468
40469
40470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40471   void * jresult ;
40472   Dali::Radian *result = 0 ;
40473
40474   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40475   jresult = (void *)result;
40476   return jresult;
40477 }
40478
40479
40480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40481   void * jresult ;
40482   Dali::Radian *result = 0 ;
40483
40484   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40485   jresult = (void *)result;
40486   return jresult;
40487 }
40488
40489
40490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40491   void * jresult ;
40492   Dali::Radian *result = 0 ;
40493
40494   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40495   jresult = (void *)result;
40496   return jresult;
40497 }
40498
40499
40500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40501   void * jresult ;
40502   Dali::Radian *result = 0 ;
40503
40504   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40505   jresult = (void *)result;
40506   return jresult;
40507 }
40508
40509
40510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40511   void * jresult ;
40512   Dali::Radian *result = 0 ;
40513
40514   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40515   jresult = (void *)result;
40516   return jresult;
40517 }
40518
40519
40520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40521   void * jresult ;
40522   Dali::PanGestureDetector *result = 0 ;
40523
40524   {
40525     try {
40526       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40527     } catch (std::out_of_range& e) {
40528       {
40529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40530       };
40531     } catch (std::exception& e) {
40532       {
40533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40534       };
40535     } catch (Dali::DaliException e) {
40536       {
40537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40538       };
40539     } catch (...) {
40540       {
40541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40542       };
40543     }
40544   }
40545
40546   jresult = (void *)result;
40547   return jresult;
40548 }
40549
40550
40551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40552   void * jresult ;
40553   Dali::PanGestureDetector result;
40554
40555   {
40556     try {
40557       result = Dali::PanGestureDetector::New();
40558     } catch (std::out_of_range& e) {
40559       {
40560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40561       };
40562     } catch (std::exception& e) {
40563       {
40564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40565       };
40566     } catch (Dali::DaliException e) {
40567       {
40568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40569       };
40570     } catch (...) {
40571       {
40572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40573       };
40574     }
40575   }
40576
40577   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40578   return jresult;
40579 }
40580
40581
40582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40583   void * jresult ;
40584   Dali::BaseHandle arg1 ;
40585   Dali::BaseHandle *argp1 ;
40586   Dali::PanGestureDetector result;
40587
40588   argp1 = (Dali::BaseHandle *)jarg1;
40589   if (!argp1) {
40590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40591     return 0;
40592   }
40593   arg1 = *argp1;
40594   {
40595     try {
40596       result = Dali::PanGestureDetector::DownCast(arg1);
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_delete_PanGestureDetector(void * jarg1) {
40622   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40623
40624   arg1 = (Dali::PanGestureDetector *)jarg1;
40625   {
40626     try {
40627       delete arg1;
40628     } catch (std::out_of_range& e) {
40629       {
40630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40631       };
40632     } catch (std::exception& e) {
40633       {
40634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40635       };
40636     } catch (Dali::DaliException e) {
40637       {
40638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40639       };
40640     } catch (...) {
40641       {
40642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40643       };
40644     }
40645   }
40646
40647 }
40648
40649
40650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40651   void * jresult ;
40652   Dali::PanGestureDetector *arg1 = 0 ;
40653   Dali::PanGestureDetector *result = 0 ;
40654
40655   arg1 = (Dali::PanGestureDetector *)jarg1;
40656   if (!arg1) {
40657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40658     return 0;
40659   }
40660   {
40661     try {
40662       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40663     } catch (std::out_of_range& e) {
40664       {
40665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40666       };
40667     } catch (std::exception& e) {
40668       {
40669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40670       };
40671     } catch (Dali::DaliException e) {
40672       {
40673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40674       };
40675     } catch (...) {
40676       {
40677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40678       };
40679     }
40680   }
40681
40682   jresult = (void *)result;
40683   return jresult;
40684 }
40685
40686
40687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40688   void * jresult ;
40689   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40690   Dali::PanGestureDetector *arg2 = 0 ;
40691   Dali::PanGestureDetector *result = 0 ;
40692
40693   arg1 = (Dali::PanGestureDetector *)jarg1;
40694   arg2 = (Dali::PanGestureDetector *)jarg2;
40695   if (!arg2) {
40696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40697     return 0;
40698   }
40699   {
40700     try {
40701       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
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_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40727   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40728   unsigned int arg2 ;
40729
40730   arg1 = (Dali::PanGestureDetector *)jarg1;
40731   arg2 = (unsigned int)jarg2;
40732   {
40733     try {
40734       (arg1)->SetMinimumTouchesRequired(arg2);
40735     } catch (std::out_of_range& e) {
40736       {
40737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40738       };
40739     } catch (std::exception& e) {
40740       {
40741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40742       };
40743     } catch (Dali::DaliException e) {
40744       {
40745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40746       };
40747     } catch (...) {
40748       {
40749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40750       };
40751     }
40752   }
40753
40754 }
40755
40756
40757 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40758   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40759   unsigned int arg2 ;
40760
40761   arg1 = (Dali::PanGestureDetector *)jarg1;
40762   arg2 = (unsigned int)jarg2;
40763   {
40764     try {
40765       (arg1)->SetMaximumTouchesRequired(arg2);
40766     } catch (std::out_of_range& e) {
40767       {
40768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40769       };
40770     } catch (std::exception& e) {
40771       {
40772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40773       };
40774     } catch (Dali::DaliException e) {
40775       {
40776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40777       };
40778     } catch (...) {
40779       {
40780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40781       };
40782     }
40783   }
40784
40785 }
40786
40787
40788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40789   unsigned int jresult ;
40790   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40791   unsigned int result;
40792
40793   arg1 = (Dali::PanGestureDetector *)jarg1;
40794   {
40795     try {
40796       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40797     } catch (std::out_of_range& e) {
40798       {
40799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40800       };
40801     } catch (std::exception& e) {
40802       {
40803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40804       };
40805     } catch (Dali::DaliException e) {
40806       {
40807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40808       };
40809     } catch (...) {
40810       {
40811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40812       };
40813     }
40814   }
40815
40816   jresult = result;
40817   return jresult;
40818 }
40819
40820
40821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40822   unsigned int jresult ;
40823   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40824   unsigned int result;
40825
40826   arg1 = (Dali::PanGestureDetector *)jarg1;
40827   {
40828     try {
40829       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40830     } catch (std::out_of_range& e) {
40831       {
40832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40833       };
40834     } catch (std::exception& e) {
40835       {
40836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40837       };
40838     } catch (Dali::DaliException e) {
40839       {
40840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40841       };
40842     } catch (...) {
40843       {
40844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40845       };
40846     }
40847   }
40848
40849   jresult = result;
40850   return jresult;
40851 }
40852
40853
40854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40855   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40856   Dali::Radian arg2 ;
40857   Dali::Radian arg3 ;
40858   Dali::Radian *argp2 ;
40859   Dali::Radian *argp3 ;
40860
40861   arg1 = (Dali::PanGestureDetector *)jarg1;
40862   argp2 = (Dali::Radian *)jarg2;
40863   if (!argp2) {
40864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40865     return ;
40866   }
40867   arg2 = *argp2;
40868   argp3 = (Dali::Radian *)jarg3;
40869   if (!argp3) {
40870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40871     return ;
40872   }
40873   arg3 = *argp3;
40874   {
40875     try {
40876       (arg1)->AddAngle(arg2,arg3);
40877     } catch (std::out_of_range& e) {
40878       {
40879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40880       };
40881     } catch (std::exception& e) {
40882       {
40883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40884       };
40885     } catch (Dali::DaliException e) {
40886       {
40887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40888       };
40889     } catch (...) {
40890       {
40891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40892       };
40893     }
40894   }
40895
40896 }
40897
40898
40899 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40900   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40901   Dali::Radian arg2 ;
40902   Dali::Radian *argp2 ;
40903
40904   arg1 = (Dali::PanGestureDetector *)jarg1;
40905   argp2 = (Dali::Radian *)jarg2;
40906   if (!argp2) {
40907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40908     return ;
40909   }
40910   arg2 = *argp2;
40911   {
40912     try {
40913       (arg1)->AddAngle(arg2);
40914     } catch (std::out_of_range& e) {
40915       {
40916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40917       };
40918     } catch (std::exception& e) {
40919       {
40920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40921       };
40922     } catch (Dali::DaliException e) {
40923       {
40924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40925       };
40926     } catch (...) {
40927       {
40928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40929       };
40930     }
40931   }
40932
40933 }
40934
40935
40936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40937   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40938   Dali::Radian arg2 ;
40939   Dali::Radian arg3 ;
40940   Dali::Radian *argp2 ;
40941   Dali::Radian *argp3 ;
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   argp3 = (Dali::Radian *)jarg3;
40951   if (!argp3) {
40952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40953     return ;
40954   }
40955   arg3 = *argp3;
40956   {
40957     try {
40958       (arg1)->AddDirection(arg2,arg3);
40959     } catch (std::out_of_range& e) {
40960       {
40961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40962       };
40963     } catch (std::exception& e) {
40964       {
40965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40966       };
40967     } catch (Dali::DaliException e) {
40968       {
40969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40970       };
40971     } catch (...) {
40972       {
40973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40974       };
40975     }
40976   }
40977
40978 }
40979
40980
40981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40982   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40983   Dali::Radian arg2 ;
40984   Dali::Radian *argp2 ;
40985
40986   arg1 = (Dali::PanGestureDetector *)jarg1;
40987   argp2 = (Dali::Radian *)jarg2;
40988   if (!argp2) {
40989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40990     return ;
40991   }
40992   arg2 = *argp2;
40993   {
40994     try {
40995       (arg1)->AddDirection(arg2);
40996     } catch (std::out_of_range& e) {
40997       {
40998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40999       };
41000     } catch (std::exception& e) {
41001       {
41002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41003       };
41004     } catch (Dali::DaliException e) {
41005       {
41006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41007       };
41008     } catch (...) {
41009       {
41010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41011       };
41012     }
41013   }
41014
41015 }
41016
41017
41018 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41019   unsigned long jresult ;
41020   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41021   size_t result;
41022
41023   arg1 = (Dali::PanGestureDetector *)jarg1;
41024   {
41025     try {
41026       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41027     } catch (std::out_of_range& e) {
41028       {
41029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41030       };
41031     } catch (std::exception& e) {
41032       {
41033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41034       };
41035     } catch (Dali::DaliException e) {
41036       {
41037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41038       };
41039     } catch (...) {
41040       {
41041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41042       };
41043     }
41044   }
41045
41046   jresult = (unsigned long)result;
41047   return jresult;
41048 }
41049
41050
41051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41052   void * jresult ;
41053   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41054   size_t arg2 ;
41055   Dali::PanGestureDetector::AngleThresholdPair result;
41056
41057   arg1 = (Dali::PanGestureDetector *)jarg1;
41058   arg2 = (size_t)jarg2;
41059   {
41060     try {
41061       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41062     } catch (std::out_of_range& e) {
41063       {
41064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41065       };
41066     } catch (std::exception& e) {
41067       {
41068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41069       };
41070     } catch (Dali::DaliException e) {
41071       {
41072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41073       };
41074     } catch (...) {
41075       {
41076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41077       };
41078     }
41079   }
41080
41081   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41082   return jresult;
41083 }
41084
41085
41086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41087   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41088
41089   arg1 = (Dali::PanGestureDetector *)jarg1;
41090   {
41091     try {
41092       (arg1)->ClearAngles();
41093     } catch (std::out_of_range& e) {
41094       {
41095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41096       };
41097     } catch (std::exception& e) {
41098       {
41099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41100       };
41101     } catch (Dali::DaliException e) {
41102       {
41103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41104       };
41105     } catch (...) {
41106       {
41107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41108       };
41109     }
41110   }
41111
41112 }
41113
41114
41115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41116   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41117   Dali::Radian arg2 ;
41118   Dali::Radian *argp2 ;
41119
41120   arg1 = (Dali::PanGestureDetector *)jarg1;
41121   argp2 = (Dali::Radian *)jarg2;
41122   if (!argp2) {
41123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41124     return ;
41125   }
41126   arg2 = *argp2;
41127   {
41128     try {
41129       (arg1)->RemoveAngle(arg2);
41130     } catch (std::out_of_range& e) {
41131       {
41132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41133       };
41134     } catch (std::exception& e) {
41135       {
41136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41137       };
41138     } catch (Dali::DaliException e) {
41139       {
41140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41141       };
41142     } catch (...) {
41143       {
41144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41145       };
41146     }
41147   }
41148
41149 }
41150
41151
41152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41153   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41154   Dali::Radian arg2 ;
41155   Dali::Radian *argp2 ;
41156
41157   arg1 = (Dali::PanGestureDetector *)jarg1;
41158   argp2 = (Dali::Radian *)jarg2;
41159   if (!argp2) {
41160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41161     return ;
41162   }
41163   arg2 = *argp2;
41164   {
41165     try {
41166       (arg1)->RemoveDirection(arg2);
41167     } catch (std::out_of_range& e) {
41168       {
41169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41170       };
41171     } catch (std::exception& e) {
41172       {
41173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41174       };
41175     } catch (Dali::DaliException e) {
41176       {
41177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41178       };
41179     } catch (...) {
41180       {
41181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41182       };
41183     }
41184   }
41185
41186 }
41187
41188
41189 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41190   void * jresult ;
41191   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41192   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41193
41194   arg1 = (Dali::PanGestureDetector *)jarg1;
41195   {
41196     try {
41197       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41198     } catch (std::out_of_range& e) {
41199       {
41200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41201       };
41202     } catch (std::exception& e) {
41203       {
41204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41205       };
41206     } catch (Dali::DaliException e) {
41207       {
41208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41209       };
41210     } catch (...) {
41211       {
41212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41213       };
41214     }
41215   }
41216
41217   jresult = (void *)result;
41218   return jresult;
41219 }
41220
41221
41222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41223   Dali::PanGesture *arg1 = 0 ;
41224
41225   arg1 = (Dali::PanGesture *)jarg1;
41226   if (!arg1) {
41227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41228     return ;
41229   }
41230   {
41231     try {
41232       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41233     } catch (std::out_of_range& e) {
41234       {
41235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41236       };
41237     } catch (std::exception& e) {
41238       {
41239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41240       };
41241     } catch (Dali::DaliException e) {
41242       {
41243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41244       };
41245     } catch (...) {
41246       {
41247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41248       };
41249     }
41250   }
41251
41252 }
41253
41254
41255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41256   void * jresult ;
41257   Dali::PanGesture *result = 0 ;
41258
41259   {
41260     try {
41261       result = (Dali::PanGesture *)new Dali::PanGesture();
41262     } catch (std::out_of_range& e) {
41263       {
41264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41265       };
41266     } catch (std::exception& e) {
41267       {
41268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41269       };
41270     } catch (Dali::DaliException e) {
41271       {
41272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41273       };
41274     } catch (...) {
41275       {
41276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41277       };
41278     }
41279   }
41280
41281   jresult = (void *)result;
41282   return jresult;
41283 }
41284
41285
41286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41287   void * jresult ;
41288   Dali::Gesture::State arg1 ;
41289   Dali::PanGesture *result = 0 ;
41290
41291   arg1 = (Dali::Gesture::State)jarg1;
41292   {
41293     try {
41294       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41295     } catch (std::out_of_range& e) {
41296       {
41297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41298       };
41299     } catch (std::exception& e) {
41300       {
41301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41302       };
41303     } catch (Dali::DaliException e) {
41304       {
41305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41306       };
41307     } catch (...) {
41308       {
41309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41310       };
41311     }
41312   }
41313
41314   jresult = (void *)result;
41315   return jresult;
41316 }
41317
41318
41319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41320   void * jresult ;
41321   Dali::PanGesture *arg1 = 0 ;
41322   Dali::PanGesture *result = 0 ;
41323
41324   arg1 = (Dali::PanGesture *)jarg1;
41325   if (!arg1) {
41326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41327     return 0;
41328   }
41329   {
41330     try {
41331       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41332     } catch (std::out_of_range& e) {
41333       {
41334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41335       };
41336     } catch (std::exception& e) {
41337       {
41338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41339       };
41340     } catch (Dali::DaliException e) {
41341       {
41342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41343       };
41344     } catch (...) {
41345       {
41346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41347       };
41348     }
41349   }
41350
41351   jresult = (void *)result;
41352   return jresult;
41353 }
41354
41355
41356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41357   void * jresult ;
41358   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41359   Dali::PanGesture *arg2 = 0 ;
41360   Dali::PanGesture *result = 0 ;
41361
41362   arg1 = (Dali::PanGesture *)jarg1;
41363   arg2 = (Dali::PanGesture *)jarg2;
41364   if (!arg2) {
41365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41366     return 0;
41367   }
41368   {
41369     try {
41370       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
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_delete_PanGesture(void * jarg1) {
41396   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41397
41398   arg1 = (Dali::PanGesture *)jarg1;
41399   {
41400     try {
41401       delete arg1;
41402     } catch (std::out_of_range& e) {
41403       {
41404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41405       };
41406     } catch (std::exception& e) {
41407       {
41408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41409       };
41410     } catch (Dali::DaliException e) {
41411       {
41412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41413       };
41414     } catch (...) {
41415       {
41416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41417       };
41418     }
41419   }
41420
41421 }
41422
41423
41424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41425   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41426   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41427
41428   arg1 = (Dali::PanGesture *)jarg1;
41429   arg2 = (Dali::Vector2 *)jarg2;
41430   if (arg1) (arg1)->velocity = *arg2;
41431 }
41432
41433
41434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41435   void * jresult ;
41436   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41437   Dali::Vector2 *result = 0 ;
41438
41439   arg1 = (Dali::PanGesture *)jarg1;
41440   result = (Dali::Vector2 *)& ((arg1)->velocity);
41441   jresult = (void *)result;
41442   return jresult;
41443 }
41444
41445
41446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41447   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41448   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41449
41450   arg1 = (Dali::PanGesture *)jarg1;
41451   arg2 = (Dali::Vector2 *)jarg2;
41452   if (arg1) (arg1)->displacement = *arg2;
41453 }
41454
41455
41456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41457   void * jresult ;
41458   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41459   Dali::Vector2 *result = 0 ;
41460
41461   arg1 = (Dali::PanGesture *)jarg1;
41462   result = (Dali::Vector2 *)& ((arg1)->displacement);
41463   jresult = (void *)result;
41464   return jresult;
41465 }
41466
41467
41468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41469   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41470   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41471
41472   arg1 = (Dali::PanGesture *)jarg1;
41473   arg2 = (Dali::Vector2 *)jarg2;
41474   if (arg1) (arg1)->position = *arg2;
41475 }
41476
41477
41478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41479   void * jresult ;
41480   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41481   Dali::Vector2 *result = 0 ;
41482
41483   arg1 = (Dali::PanGesture *)jarg1;
41484   result = (Dali::Vector2 *)& ((arg1)->position);
41485   jresult = (void *)result;
41486   return jresult;
41487 }
41488
41489
41490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41491   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41492   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41493
41494   arg1 = (Dali::PanGesture *)jarg1;
41495   arg2 = (Dali::Vector2 *)jarg2;
41496   if (arg1) (arg1)->screenVelocity = *arg2;
41497 }
41498
41499
41500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41501   void * jresult ;
41502   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41503   Dali::Vector2 *result = 0 ;
41504
41505   arg1 = (Dali::PanGesture *)jarg1;
41506   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41507   jresult = (void *)result;
41508   return jresult;
41509 }
41510
41511
41512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41513   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41514   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41515
41516   arg1 = (Dali::PanGesture *)jarg1;
41517   arg2 = (Dali::Vector2 *)jarg2;
41518   if (arg1) (arg1)->screenDisplacement = *arg2;
41519 }
41520
41521
41522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41523   void * jresult ;
41524   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41525   Dali::Vector2 *result = 0 ;
41526
41527   arg1 = (Dali::PanGesture *)jarg1;
41528   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41529   jresult = (void *)result;
41530   return jresult;
41531 }
41532
41533
41534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41535   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41536   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41537
41538   arg1 = (Dali::PanGesture *)jarg1;
41539   arg2 = (Dali::Vector2 *)jarg2;
41540   if (arg1) (arg1)->screenPosition = *arg2;
41541 }
41542
41543
41544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41545   void * jresult ;
41546   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41547   Dali::Vector2 *result = 0 ;
41548
41549   arg1 = (Dali::PanGesture *)jarg1;
41550   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41551   jresult = (void *)result;
41552   return jresult;
41553 }
41554
41555
41556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41557   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41558   unsigned int arg2 ;
41559
41560   arg1 = (Dali::PanGesture *)jarg1;
41561   arg2 = (unsigned int)jarg2;
41562   if (arg1) (arg1)->numberOfTouches = arg2;
41563 }
41564
41565
41566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41567   unsigned int jresult ;
41568   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41569   unsigned int result;
41570
41571   arg1 = (Dali::PanGesture *)jarg1;
41572   result = (unsigned int) ((arg1)->numberOfTouches);
41573   jresult = result;
41574   return jresult;
41575 }
41576
41577
41578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41579   float jresult ;
41580   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41581   float result;
41582
41583   arg1 = (Dali::PanGesture *)jarg1;
41584   {
41585     try {
41586       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41587     } catch (std::out_of_range& e) {
41588       {
41589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41590       };
41591     } catch (std::exception& e) {
41592       {
41593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41594       };
41595     } catch (Dali::DaliException e) {
41596       {
41597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41598       };
41599     } catch (...) {
41600       {
41601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41602       };
41603     }
41604   }
41605
41606   jresult = result;
41607   return jresult;
41608 }
41609
41610
41611 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41612   float jresult ;
41613   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41614   float result;
41615
41616   arg1 = (Dali::PanGesture *)jarg1;
41617   {
41618     try {
41619       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41620     } catch (std::out_of_range& e) {
41621       {
41622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41623       };
41624     } catch (std::exception& e) {
41625       {
41626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41627       };
41628     } catch (Dali::DaliException e) {
41629       {
41630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41631       };
41632     } catch (...) {
41633       {
41634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41635       };
41636     }
41637   }
41638
41639   jresult = result;
41640   return jresult;
41641 }
41642
41643
41644 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41645   float jresult ;
41646   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41647   float result;
41648
41649   arg1 = (Dali::PanGesture *)jarg1;
41650   {
41651     try {
41652       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41653     } catch (std::out_of_range& e) {
41654       {
41655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41656       };
41657     } catch (std::exception& e) {
41658       {
41659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41660       };
41661     } catch (Dali::DaliException e) {
41662       {
41663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41664       };
41665     } catch (...) {
41666       {
41667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41668       };
41669     }
41670   }
41671
41672   jresult = result;
41673   return jresult;
41674 }
41675
41676
41677 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41678   float jresult ;
41679   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41680   float result;
41681
41682   arg1 = (Dali::PanGesture *)jarg1;
41683   {
41684     try {
41685       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41686     } catch (std::out_of_range& e) {
41687       {
41688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41689       };
41690     } catch (std::exception& e) {
41691       {
41692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41693       };
41694     } catch (Dali::DaliException e) {
41695       {
41696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41697       };
41698     } catch (...) {
41699       {
41700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41701       };
41702     }
41703   }
41704
41705   jresult = result;
41706   return jresult;
41707 }
41708
41709
41710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41711   void * jresult ;
41712   Dali::PinchGestureDetector *result = 0 ;
41713
41714   {
41715     try {
41716       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41717     } catch (std::out_of_range& e) {
41718       {
41719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41720       };
41721     } catch (std::exception& e) {
41722       {
41723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41724       };
41725     } catch (Dali::DaliException e) {
41726       {
41727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41728       };
41729     } catch (...) {
41730       {
41731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41732       };
41733     }
41734   }
41735
41736   jresult = (void *)result;
41737   return jresult;
41738 }
41739
41740
41741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41742   void * jresult ;
41743   Dali::PinchGestureDetector result;
41744
41745   {
41746     try {
41747       result = Dali::PinchGestureDetector::New();
41748     } catch (std::out_of_range& e) {
41749       {
41750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41751       };
41752     } catch (std::exception& e) {
41753       {
41754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41755       };
41756     } catch (Dali::DaliException e) {
41757       {
41758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41759       };
41760     } catch (...) {
41761       {
41762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41763       };
41764     }
41765   }
41766
41767   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41768   return jresult;
41769 }
41770
41771
41772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41773   void * jresult ;
41774   Dali::BaseHandle arg1 ;
41775   Dali::BaseHandle *argp1 ;
41776   Dali::PinchGestureDetector result;
41777
41778   argp1 = (Dali::BaseHandle *)jarg1;
41779   if (!argp1) {
41780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41781     return 0;
41782   }
41783   arg1 = *argp1;
41784   {
41785     try {
41786       result = Dali::PinchGestureDetector::DownCast(arg1);
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_delete_PinchGestureDetector(void * jarg1) {
41812   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41813
41814   arg1 = (Dali::PinchGestureDetector *)jarg1;
41815   {
41816     try {
41817       delete arg1;
41818     } catch (std::out_of_range& e) {
41819       {
41820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41821       };
41822     } catch (std::exception& e) {
41823       {
41824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41825       };
41826     } catch (Dali::DaliException e) {
41827       {
41828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41829       };
41830     } catch (...) {
41831       {
41832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41833       };
41834     }
41835   }
41836
41837 }
41838
41839
41840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41841   void * jresult ;
41842   Dali::PinchGestureDetector *arg1 = 0 ;
41843   Dali::PinchGestureDetector *result = 0 ;
41844
41845   arg1 = (Dali::PinchGestureDetector *)jarg1;
41846   if (!arg1) {
41847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41848     return 0;
41849   }
41850   {
41851     try {
41852       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41853     } catch (std::out_of_range& e) {
41854       {
41855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41856       };
41857     } catch (std::exception& e) {
41858       {
41859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41860       };
41861     } catch (Dali::DaliException e) {
41862       {
41863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41864       };
41865     } catch (...) {
41866       {
41867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41868       };
41869     }
41870   }
41871
41872   jresult = (void *)result;
41873   return jresult;
41874 }
41875
41876
41877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41878   void * jresult ;
41879   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41880   Dali::PinchGestureDetector *arg2 = 0 ;
41881   Dali::PinchGestureDetector *result = 0 ;
41882
41883   arg1 = (Dali::PinchGestureDetector *)jarg1;
41884   arg2 = (Dali::PinchGestureDetector *)jarg2;
41885   if (!arg2) {
41886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41887     return 0;
41888   }
41889   {
41890     try {
41891       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
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_DetectedSignal(void * jarg1) {
41917   void * jresult ;
41918   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41919   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41920
41921   arg1 = (Dali::PinchGestureDetector *)jarg1;
41922   {
41923     try {
41924       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41925     } catch (std::out_of_range& e) {
41926       {
41927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41928       };
41929     } catch (std::exception& e) {
41930       {
41931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41932       };
41933     } catch (Dali::DaliException e) {
41934       {
41935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41936       };
41937     } catch (...) {
41938       {
41939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41940       };
41941     }
41942   }
41943
41944   jresult = (void *)result;
41945   return jresult;
41946 }
41947
41948
41949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41950   void * jresult ;
41951   Dali::Gesture::State arg1 ;
41952   Dali::PinchGesture *result = 0 ;
41953
41954   arg1 = (Dali::Gesture::State)jarg1;
41955   {
41956     try {
41957       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41958     } catch (std::out_of_range& e) {
41959       {
41960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41961       };
41962     } catch (std::exception& e) {
41963       {
41964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41965       };
41966     } catch (Dali::DaliException e) {
41967       {
41968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41969       };
41970     } catch (...) {
41971       {
41972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41973       };
41974     }
41975   }
41976
41977   jresult = (void *)result;
41978   return jresult;
41979 }
41980
41981
41982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41983   void * jresult ;
41984   Dali::PinchGesture *arg1 = 0 ;
41985   Dali::PinchGesture *result = 0 ;
41986
41987   arg1 = (Dali::PinchGesture *)jarg1;
41988   if (!arg1) {
41989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41990     return 0;
41991   }
41992   {
41993     try {
41994       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41995     } catch (std::out_of_range& e) {
41996       {
41997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41998       };
41999     } catch (std::exception& e) {
42000       {
42001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42002       };
42003     } catch (Dali::DaliException e) {
42004       {
42005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42006       };
42007     } catch (...) {
42008       {
42009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42010       };
42011     }
42012   }
42013
42014   jresult = (void *)result;
42015   return jresult;
42016 }
42017
42018
42019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42020   void * jresult ;
42021   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42022   Dali::PinchGesture *arg2 = 0 ;
42023   Dali::PinchGesture *result = 0 ;
42024
42025   arg1 = (Dali::PinchGesture *)jarg1;
42026   arg2 = (Dali::PinchGesture *)jarg2;
42027   if (!arg2) {
42028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42029     return 0;
42030   }
42031   {
42032     try {
42033       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
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_delete_PinchGesture(void * jarg1) {
42059   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42060
42061   arg1 = (Dali::PinchGesture *)jarg1;
42062   {
42063     try {
42064       delete arg1;
42065     } catch (std::out_of_range& e) {
42066       {
42067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42068       };
42069     } catch (std::exception& e) {
42070       {
42071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42072       };
42073     } catch (Dali::DaliException e) {
42074       {
42075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42076       };
42077     } catch (...) {
42078       {
42079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42080       };
42081     }
42082   }
42083
42084 }
42085
42086
42087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42088   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42089   float arg2 ;
42090
42091   arg1 = (Dali::PinchGesture *)jarg1;
42092   arg2 = (float)jarg2;
42093   if (arg1) (arg1)->scale = arg2;
42094 }
42095
42096
42097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42098   float jresult ;
42099   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42100   float result;
42101
42102   arg1 = (Dali::PinchGesture *)jarg1;
42103   result = (float) ((arg1)->scale);
42104   jresult = result;
42105   return jresult;
42106 }
42107
42108
42109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42110   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42111   float arg2 ;
42112
42113   arg1 = (Dali::PinchGesture *)jarg1;
42114   arg2 = (float)jarg2;
42115   if (arg1) (arg1)->speed = arg2;
42116 }
42117
42118
42119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42120   float jresult ;
42121   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42122   float result;
42123
42124   arg1 = (Dali::PinchGesture *)jarg1;
42125   result = (float) ((arg1)->speed);
42126   jresult = result;
42127   return jresult;
42128 }
42129
42130
42131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42132   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42133   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42134
42135   arg1 = (Dali::PinchGesture *)jarg1;
42136   arg2 = (Dali::Vector2 *)jarg2;
42137   if (arg1) (arg1)->screenCenterPoint = *arg2;
42138 }
42139
42140
42141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42142   void * jresult ;
42143   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42144   Dali::Vector2 *result = 0 ;
42145
42146   arg1 = (Dali::PinchGesture *)jarg1;
42147   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42148   jresult = (void *)result;
42149   return jresult;
42150 }
42151
42152
42153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42154   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42155   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42156
42157   arg1 = (Dali::PinchGesture *)jarg1;
42158   arg2 = (Dali::Vector2 *)jarg2;
42159   if (arg1) (arg1)->localCenterPoint = *arg2;
42160 }
42161
42162
42163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42164   void * jresult ;
42165   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42166   Dali::Vector2 *result = 0 ;
42167
42168   arg1 = (Dali::PinchGesture *)jarg1;
42169   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42170   jresult = (void *)result;
42171   return jresult;
42172 }
42173
42174
42175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42176   void * jresult ;
42177   Dali::TapGestureDetector *result = 0 ;
42178
42179   {
42180     try {
42181       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42182     } catch (std::out_of_range& e) {
42183       {
42184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42185       };
42186     } catch (std::exception& e) {
42187       {
42188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42189       };
42190     } catch (Dali::DaliException e) {
42191       {
42192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42193       };
42194     } catch (...) {
42195       {
42196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42197       };
42198     }
42199   }
42200
42201   jresult = (void *)result;
42202   return jresult;
42203 }
42204
42205
42206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42207   void * jresult ;
42208   Dali::TapGestureDetector result;
42209
42210   {
42211     try {
42212       result = Dali::TapGestureDetector::New();
42213     } catch (std::out_of_range& e) {
42214       {
42215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42216       };
42217     } catch (std::exception& e) {
42218       {
42219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42220       };
42221     } catch (Dali::DaliException e) {
42222       {
42223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42224       };
42225     } catch (...) {
42226       {
42227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42228       };
42229     }
42230   }
42231
42232   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42233   return jresult;
42234 }
42235
42236
42237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42238   void * jresult ;
42239   unsigned int arg1 ;
42240   Dali::TapGestureDetector result;
42241
42242   arg1 = (unsigned int)jarg1;
42243   {
42244     try {
42245       result = Dali::TapGestureDetector::New(arg1);
42246     } catch (std::out_of_range& e) {
42247       {
42248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42249       };
42250     } catch (std::exception& e) {
42251       {
42252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42253       };
42254     } catch (Dali::DaliException e) {
42255       {
42256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42257       };
42258     } catch (...) {
42259       {
42260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42261       };
42262     }
42263   }
42264
42265   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42266   return jresult;
42267 }
42268
42269
42270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42271   void * jresult ;
42272   Dali::BaseHandle arg1 ;
42273   Dali::BaseHandle *argp1 ;
42274   Dali::TapGestureDetector result;
42275
42276   argp1 = (Dali::BaseHandle *)jarg1;
42277   if (!argp1) {
42278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42279     return 0;
42280   }
42281   arg1 = *argp1;
42282   {
42283     try {
42284       result = Dali::TapGestureDetector::DownCast(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_delete_TapGestureDetector(void * jarg1) {
42310   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42311
42312   arg1 = (Dali::TapGestureDetector *)jarg1;
42313   {
42314     try {
42315       delete arg1;
42316     } catch (std::out_of_range& e) {
42317       {
42318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42319       };
42320     } catch (std::exception& e) {
42321       {
42322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42323       };
42324     } catch (Dali::DaliException e) {
42325       {
42326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42327       };
42328     } catch (...) {
42329       {
42330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42331       };
42332     }
42333   }
42334
42335 }
42336
42337
42338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42339   void * jresult ;
42340   Dali::TapGestureDetector *arg1 = 0 ;
42341   Dali::TapGestureDetector *result = 0 ;
42342
42343   arg1 = (Dali::TapGestureDetector *)jarg1;
42344   if (!arg1) {
42345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42346     return 0;
42347   }
42348   {
42349     try {
42350       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42351     } catch (std::out_of_range& e) {
42352       {
42353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42354       };
42355     } catch (std::exception& e) {
42356       {
42357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42358       };
42359     } catch (Dali::DaliException e) {
42360       {
42361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42362       };
42363     } catch (...) {
42364       {
42365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42366       };
42367     }
42368   }
42369
42370   jresult = (void *)result;
42371   return jresult;
42372 }
42373
42374
42375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42376   void * jresult ;
42377   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42378   Dali::TapGestureDetector *arg2 = 0 ;
42379   Dali::TapGestureDetector *result = 0 ;
42380
42381   arg1 = (Dali::TapGestureDetector *)jarg1;
42382   arg2 = (Dali::TapGestureDetector *)jarg2;
42383   if (!arg2) {
42384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42385     return 0;
42386   }
42387   {
42388     try {
42389       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
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_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42415   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42416   unsigned int arg2 ;
42417
42418   arg1 = (Dali::TapGestureDetector *)jarg1;
42419   arg2 = (unsigned int)jarg2;
42420   {
42421     try {
42422       (arg1)->SetMinimumTapsRequired(arg2);
42423     } catch (std::out_of_range& e) {
42424       {
42425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42426       };
42427     } catch (std::exception& e) {
42428       {
42429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42430       };
42431     } catch (Dali::DaliException e) {
42432       {
42433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42434       };
42435     } catch (...) {
42436       {
42437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42438       };
42439     }
42440   }
42441
42442 }
42443
42444
42445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42446   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42447   unsigned int arg2 ;
42448
42449   arg1 = (Dali::TapGestureDetector *)jarg1;
42450   arg2 = (unsigned int)jarg2;
42451   {
42452     try {
42453       (arg1)->SetMaximumTapsRequired(arg2);
42454     } catch (std::out_of_range& e) {
42455       {
42456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42457       };
42458     } catch (std::exception& e) {
42459       {
42460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42461       };
42462     } catch (Dali::DaliException e) {
42463       {
42464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42465       };
42466     } catch (...) {
42467       {
42468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42469       };
42470     }
42471   }
42472
42473 }
42474
42475
42476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42477   unsigned int jresult ;
42478   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42479   unsigned int result;
42480
42481   arg1 = (Dali::TapGestureDetector *)jarg1;
42482   {
42483     try {
42484       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42485     } catch (std::out_of_range& e) {
42486       {
42487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42488       };
42489     } catch (std::exception& e) {
42490       {
42491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42492       };
42493     } catch (Dali::DaliException e) {
42494       {
42495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42496       };
42497     } catch (...) {
42498       {
42499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42500       };
42501     }
42502   }
42503
42504   jresult = result;
42505   return jresult;
42506 }
42507
42508
42509 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42510   unsigned int jresult ;
42511   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42512   unsigned int result;
42513
42514   arg1 = (Dali::TapGestureDetector *)jarg1;
42515   {
42516     try {
42517       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42518     } catch (std::out_of_range& e) {
42519       {
42520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42521       };
42522     } catch (std::exception& e) {
42523       {
42524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42525       };
42526     } catch (Dali::DaliException e) {
42527       {
42528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42529       };
42530     } catch (...) {
42531       {
42532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42533       };
42534     }
42535   }
42536
42537   jresult = result;
42538   return jresult;
42539 }
42540
42541
42542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42543   void * jresult ;
42544   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42545   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42546
42547   arg1 = (Dali::TapGestureDetector *)jarg1;
42548   {
42549     try {
42550       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42551     } catch (std::out_of_range& e) {
42552       {
42553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42554       };
42555     } catch (std::exception& e) {
42556       {
42557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42558       };
42559     } catch (Dali::DaliException e) {
42560       {
42561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42562       };
42563     } catch (...) {
42564       {
42565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42566       };
42567     }
42568   }
42569
42570   jresult = (void *)result;
42571   return jresult;
42572 }
42573
42574
42575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42576   void * jresult ;
42577   Dali::TapGesture *result = 0 ;
42578
42579   {
42580     try {
42581       result = (Dali::TapGesture *)new Dali::TapGesture();
42582     } catch (std::out_of_range& e) {
42583       {
42584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42585       };
42586     } catch (std::exception& e) {
42587       {
42588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42589       };
42590     } catch (Dali::DaliException e) {
42591       {
42592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42593       };
42594     } catch (...) {
42595       {
42596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42597       };
42598     }
42599   }
42600
42601   jresult = (void *)result;
42602   return jresult;
42603 }
42604
42605
42606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42607   void * jresult ;
42608   Dali::TapGesture *arg1 = 0 ;
42609   Dali::TapGesture *result = 0 ;
42610
42611   arg1 = (Dali::TapGesture *)jarg1;
42612   if (!arg1) {
42613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42614     return 0;
42615   }
42616   {
42617     try {
42618       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42619     } catch (std::out_of_range& e) {
42620       {
42621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42622       };
42623     } catch (std::exception& e) {
42624       {
42625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42626       };
42627     } catch (Dali::DaliException e) {
42628       {
42629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42630       };
42631     } catch (...) {
42632       {
42633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42634       };
42635     }
42636   }
42637
42638   jresult = (void *)result;
42639   return jresult;
42640 }
42641
42642
42643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42644   void * jresult ;
42645   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42646   Dali::TapGesture *arg2 = 0 ;
42647   Dali::TapGesture *result = 0 ;
42648
42649   arg1 = (Dali::TapGesture *)jarg1;
42650   arg2 = (Dali::TapGesture *)jarg2;
42651   if (!arg2) {
42652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42653     return 0;
42654   }
42655   {
42656     try {
42657       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
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_delete_TapGesture(void * jarg1) {
42683   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42684
42685   arg1 = (Dali::TapGesture *)jarg1;
42686   {
42687     try {
42688       delete arg1;
42689     } catch (std::out_of_range& e) {
42690       {
42691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42692       };
42693     } catch (std::exception& e) {
42694       {
42695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42696       };
42697     } catch (Dali::DaliException e) {
42698       {
42699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42700       };
42701     } catch (...) {
42702       {
42703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42704       };
42705     }
42706   }
42707
42708 }
42709
42710
42711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42712   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42713   unsigned int arg2 ;
42714
42715   arg1 = (Dali::TapGesture *)jarg1;
42716   arg2 = (unsigned int)jarg2;
42717   if (arg1) (arg1)->numberOfTaps = arg2;
42718 }
42719
42720
42721 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42722   unsigned int jresult ;
42723   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42724   unsigned int result;
42725
42726   arg1 = (Dali::TapGesture *)jarg1;
42727   result = (unsigned int) ((arg1)->numberOfTaps);
42728   jresult = result;
42729   return jresult;
42730 }
42731
42732
42733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42734   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42735   unsigned int arg2 ;
42736
42737   arg1 = (Dali::TapGesture *)jarg1;
42738   arg2 = (unsigned int)jarg2;
42739   if (arg1) (arg1)->numberOfTouches = arg2;
42740 }
42741
42742
42743 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42744   unsigned int jresult ;
42745   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42746   unsigned int result;
42747
42748   arg1 = (Dali::TapGesture *)jarg1;
42749   result = (unsigned int) ((arg1)->numberOfTouches);
42750   jresult = result;
42751   return jresult;
42752 }
42753
42754
42755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42756   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42757   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42758
42759   arg1 = (Dali::TapGesture *)jarg1;
42760   arg2 = (Dali::Vector2 *)jarg2;
42761   if (arg1) (arg1)->screenPoint = *arg2;
42762 }
42763
42764
42765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42766   void * jresult ;
42767   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42768   Dali::Vector2 *result = 0 ;
42769
42770   arg1 = (Dali::TapGesture *)jarg1;
42771   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42772   jresult = (void *)result;
42773   return jresult;
42774 }
42775
42776
42777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42778   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42779   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42780
42781   arg1 = (Dali::TapGesture *)jarg1;
42782   arg2 = (Dali::Vector2 *)jarg2;
42783   if (arg1) (arg1)->localPoint = *arg2;
42784 }
42785
42786
42787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42788   void * jresult ;
42789   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42790   Dali::Vector2 *result = 0 ;
42791
42792   arg1 = (Dali::TapGesture *)jarg1;
42793   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42794   jresult = (void *)result;
42795   return jresult;
42796 }
42797
42798
42799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42800   void * jresult ;
42801   Dali::AlphaFunction *result = 0 ;
42802
42803   {
42804     try {
42805       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42806     } catch (std::out_of_range& e) {
42807       {
42808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42809       };
42810     } catch (std::exception& e) {
42811       {
42812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42813       };
42814     } catch (Dali::DaliException e) {
42815       {
42816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42817       };
42818     } catch (...) {
42819       {
42820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42821       };
42822     }
42823   }
42824
42825   jresult = (void *)result;
42826   return jresult;
42827 }
42828
42829
42830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42831   void * jresult ;
42832   Dali::AlphaFunction::BuiltinFunction arg1 ;
42833   Dali::AlphaFunction *result = 0 ;
42834
42835   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42836   {
42837     try {
42838       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42839     } catch (std::out_of_range& e) {
42840       {
42841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42842       };
42843     } catch (std::exception& e) {
42844       {
42845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42846       };
42847     } catch (Dali::DaliException e) {
42848       {
42849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42850       };
42851     } catch (...) {
42852       {
42853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42854       };
42855     }
42856   }
42857
42858   jresult = (void *)result;
42859   return jresult;
42860 }
42861
42862
42863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42864   void * jresult ;
42865   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42866   Dali::AlphaFunction *result = 0 ;
42867
42868   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42869   {
42870     try {
42871       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42872     } catch (std::out_of_range& e) {
42873       {
42874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42875       };
42876     } catch (std::exception& e) {
42877       {
42878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42879       };
42880     } catch (Dali::DaliException e) {
42881       {
42882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42883       };
42884     } catch (...) {
42885       {
42886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42887       };
42888     }
42889   }
42890
42891   jresult = (void *)result;
42892   return jresult;
42893 }
42894
42895
42896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42897   void * jresult ;
42898   Dali::Vector2 *arg1 = 0 ;
42899   Dali::Vector2 *arg2 = 0 ;
42900   Dali::AlphaFunction *result = 0 ;
42901
42902   arg1 = (Dali::Vector2 *)jarg1;
42903   if (!arg1) {
42904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42905     return 0;
42906   }
42907   arg2 = (Dali::Vector2 *)jarg2;
42908   if (!arg2) {
42909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42910     return 0;
42911   }
42912   {
42913     try {
42914       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42915     } catch (std::out_of_range& e) {
42916       {
42917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42918       };
42919     } catch (std::exception& e) {
42920       {
42921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42922       };
42923     } catch (Dali::DaliException e) {
42924       {
42925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42926       };
42927     } catch (...) {
42928       {
42929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42930       };
42931     }
42932   }
42933
42934   jresult = (void *)result;
42935   return jresult;
42936 }
42937
42938
42939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42940   void * jresult ;
42941   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42942   Dali::Vector4 result;
42943
42944   arg1 = (Dali::AlphaFunction *)jarg1;
42945   {
42946     try {
42947       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42948     } catch (std::out_of_range& e) {
42949       {
42950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42951       };
42952     } catch (std::exception& e) {
42953       {
42954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42955       };
42956     } catch (Dali::DaliException e) {
42957       {
42958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42959       };
42960     } catch (...) {
42961       {
42962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42963       };
42964     }
42965   }
42966
42967   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42968   return jresult;
42969 }
42970
42971
42972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42973   void * jresult ;
42974   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42975   Dali::AlphaFunctionPrototype result;
42976
42977   arg1 = (Dali::AlphaFunction *)jarg1;
42978   {
42979     try {
42980       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42981     } catch (std::out_of_range& e) {
42982       {
42983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42984       };
42985     } catch (std::exception& e) {
42986       {
42987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42988       };
42989     } catch (Dali::DaliException e) {
42990       {
42991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42992       };
42993     } catch (...) {
42994       {
42995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42996       };
42997     }
42998   }
42999
43000   jresult = (void *)result;
43001   return jresult;
43002 }
43003
43004
43005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43006   int jresult ;
43007   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43008   Dali::AlphaFunction::BuiltinFunction result;
43009
43010   arg1 = (Dali::AlphaFunction *)jarg1;
43011   {
43012     try {
43013       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43014     } catch (std::out_of_range& e) {
43015       {
43016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43017       };
43018     } catch (std::exception& e) {
43019       {
43020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43021       };
43022     } catch (Dali::DaliException e) {
43023       {
43024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43025       };
43026     } catch (...) {
43027       {
43028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43029       };
43030     }
43031   }
43032
43033   jresult = (int)result;
43034   return jresult;
43035 }
43036
43037
43038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43039   int jresult ;
43040   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43041   Dali::AlphaFunction::Mode result;
43042
43043   arg1 = (Dali::AlphaFunction *)jarg1;
43044   {
43045     try {
43046       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43047     } catch (std::out_of_range& e) {
43048       {
43049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43050       };
43051     } catch (std::exception& e) {
43052       {
43053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43054       };
43055     } catch (Dali::DaliException e) {
43056       {
43057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43058       };
43059     } catch (...) {
43060       {
43061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43062       };
43063     }
43064   }
43065
43066   jresult = (int)result;
43067   return jresult;
43068 }
43069
43070
43071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43072   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43073
43074   arg1 = (Dali::AlphaFunction *)jarg1;
43075   {
43076     try {
43077       delete arg1;
43078     } catch (std::out_of_range& e) {
43079       {
43080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43081       };
43082     } catch (std::exception& e) {
43083       {
43084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43085       };
43086     } catch (Dali::DaliException e) {
43087       {
43088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43089       };
43090     } catch (...) {
43091       {
43092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43093       };
43094     }
43095   }
43096
43097 }
43098
43099
43100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43101   void * jresult ;
43102   Dali::KeyFrames result;
43103
43104   {
43105     try {
43106       result = Dali::KeyFrames::New();
43107     } catch (std::out_of_range& e) {
43108       {
43109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43110       };
43111     } catch (std::exception& e) {
43112       {
43113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43114       };
43115     } catch (Dali::DaliException e) {
43116       {
43117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43118       };
43119     } catch (...) {
43120       {
43121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43122       };
43123     }
43124   }
43125
43126   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43127   return jresult;
43128 }
43129
43130
43131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43132   void * jresult ;
43133   Dali::BaseHandle arg1 ;
43134   Dali::BaseHandle *argp1 ;
43135   Dali::KeyFrames result;
43136
43137   argp1 = (Dali::BaseHandle *)jarg1;
43138   if (!argp1) {
43139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43140     return 0;
43141   }
43142   arg1 = *argp1;
43143   {
43144     try {
43145       result = Dali::KeyFrames::DownCast(arg1);
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_new_KeyFrames__SWIG_0() {
43171   void * jresult ;
43172   Dali::KeyFrames *result = 0 ;
43173
43174   {
43175     try {
43176       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43177     } catch (std::out_of_range& e) {
43178       {
43179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43180       };
43181     } catch (std::exception& e) {
43182       {
43183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43184       };
43185     } catch (Dali::DaliException e) {
43186       {
43187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43188       };
43189     } catch (...) {
43190       {
43191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43192       };
43193     }
43194   }
43195
43196   jresult = (void *)result;
43197   return jresult;
43198 }
43199
43200
43201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43202   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43203
43204   arg1 = (Dali::KeyFrames *)jarg1;
43205   {
43206     try {
43207       delete arg1;
43208     } catch (std::out_of_range& e) {
43209       {
43210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43211       };
43212     } catch (std::exception& e) {
43213       {
43214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43215       };
43216     } catch (Dali::DaliException e) {
43217       {
43218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43219       };
43220     } catch (...) {
43221       {
43222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43223       };
43224     }
43225   }
43226
43227 }
43228
43229
43230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43231   void * jresult ;
43232   Dali::KeyFrames *arg1 = 0 ;
43233   Dali::KeyFrames *result = 0 ;
43234
43235   arg1 = (Dali::KeyFrames *)jarg1;
43236   if (!arg1) {
43237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43238     return 0;
43239   }
43240   {
43241     try {
43242       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43243     } catch (std::out_of_range& e) {
43244       {
43245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43246       };
43247     } catch (std::exception& e) {
43248       {
43249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43250       };
43251     } catch (Dali::DaliException e) {
43252       {
43253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43254       };
43255     } catch (...) {
43256       {
43257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43258       };
43259     }
43260   }
43261
43262   jresult = (void *)result;
43263   return jresult;
43264 }
43265
43266
43267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43268   void * jresult ;
43269   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43270   Dali::KeyFrames *arg2 = 0 ;
43271   Dali::KeyFrames *result = 0 ;
43272
43273   arg1 = (Dali::KeyFrames *)jarg1;
43274   arg2 = (Dali::KeyFrames *)jarg2;
43275   if (!arg2) {
43276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43277     return 0;
43278   }
43279   {
43280     try {
43281       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
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 int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43307   int jresult ;
43308   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43309   Dali::Property::Type result;
43310
43311   arg1 = (Dali::KeyFrames *)jarg1;
43312   {
43313     try {
43314       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43315     } catch (std::out_of_range& e) {
43316       {
43317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43318       };
43319     } catch (std::exception& e) {
43320       {
43321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43322       };
43323     } catch (Dali::DaliException e) {
43324       {
43325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43326       };
43327     } catch (...) {
43328       {
43329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43330       };
43331     }
43332   }
43333
43334   jresult = (int)result;
43335   return jresult;
43336 }
43337
43338
43339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43340   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43341   float arg2 ;
43342   Dali::Property::Value arg3 ;
43343   Dali::Property::Value *argp3 ;
43344
43345   arg1 = (Dali::KeyFrames *)jarg1;
43346   arg2 = (float)jarg2;
43347   argp3 = (Dali::Property::Value *)jarg3;
43348   if (!argp3) {
43349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43350     return ;
43351   }
43352   arg3 = *argp3;
43353   {
43354     try {
43355       (arg1)->Add(arg2,arg3);
43356     } catch (std::out_of_range& e) {
43357       {
43358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43359       };
43360     } catch (std::exception& e) {
43361       {
43362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43363       };
43364     } catch (Dali::DaliException e) {
43365       {
43366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43367       };
43368     } catch (...) {
43369       {
43370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43371       };
43372     }
43373   }
43374
43375 }
43376
43377
43378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43379   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43380   float arg2 ;
43381   Dali::Property::Value arg3 ;
43382   Dali::AlphaFunction arg4 ;
43383   Dali::Property::Value *argp3 ;
43384   Dali::AlphaFunction *argp4 ;
43385
43386   arg1 = (Dali::KeyFrames *)jarg1;
43387   arg2 = (float)jarg2;
43388   argp3 = (Dali::Property::Value *)jarg3;
43389   if (!argp3) {
43390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43391     return ;
43392   }
43393   arg3 = *argp3;
43394   argp4 = (Dali::AlphaFunction *)jarg4;
43395   if (!argp4) {
43396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43397     return ;
43398   }
43399   arg4 = *argp4;
43400   {
43401     try {
43402       (arg1)->Add(arg2,arg3,arg4);
43403     } catch (std::out_of_range& e) {
43404       {
43405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43406       };
43407     } catch (std::exception& e) {
43408       {
43409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43410       };
43411     } catch (Dali::DaliException e) {
43412       {
43413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43414       };
43415     } catch (...) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43418       };
43419     }
43420   }
43421
43422 }
43423
43424
43425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43426   int jresult ;
43427   int result;
43428
43429   result = (int)Dali::Path::Property::POINTS;
43430   jresult = (int)result;
43431   return jresult;
43432 }
43433
43434
43435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43436   int jresult ;
43437   int result;
43438
43439   result = (int)Dali::Path::Property::CONTROL_POINTS;
43440   jresult = (int)result;
43441   return jresult;
43442 }
43443
43444
43445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43446   void * jresult ;
43447   Dali::Path::Property *result = 0 ;
43448
43449   {
43450     try {
43451       result = (Dali::Path::Property *)new Dali::Path::Property();
43452     } catch (std::out_of_range& e) {
43453       {
43454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43455       };
43456     } catch (std::exception& e) {
43457       {
43458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43459       };
43460     } catch (Dali::DaliException e) {
43461       {
43462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43463       };
43464     } catch (...) {
43465       {
43466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43467       };
43468     }
43469   }
43470
43471   jresult = (void *)result;
43472   return jresult;
43473 }
43474
43475
43476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43477   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43478
43479   arg1 = (Dali::Path::Property *)jarg1;
43480   {
43481     try {
43482       delete arg1;
43483     } catch (std::out_of_range& e) {
43484       {
43485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43486       };
43487     } catch (std::exception& e) {
43488       {
43489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43490       };
43491     } catch (Dali::DaliException e) {
43492       {
43493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43494       };
43495     } catch (...) {
43496       {
43497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43498       };
43499     }
43500   }
43501
43502 }
43503
43504
43505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43506   void * jresult ;
43507   Dali::Path result;
43508
43509   {
43510     try {
43511       result = Dali::Path::New();
43512     } catch (std::out_of_range& e) {
43513       {
43514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43515       };
43516     } catch (std::exception& e) {
43517       {
43518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43519       };
43520     } catch (Dali::DaliException e) {
43521       {
43522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43523       };
43524     } catch (...) {
43525       {
43526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43527       };
43528     }
43529   }
43530
43531   jresult = new Dali::Path((const Dali::Path &)result);
43532   return jresult;
43533 }
43534
43535
43536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43537   void * jresult ;
43538   Dali::BaseHandle arg1 ;
43539   Dali::BaseHandle *argp1 ;
43540   Dali::Path result;
43541
43542   argp1 = (Dali::BaseHandle *)jarg1;
43543   if (!argp1) {
43544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43545     return 0;
43546   }
43547   arg1 = *argp1;
43548   {
43549     try {
43550       result = Dali::Path::DownCast(arg1);
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_new_Path__SWIG_0() {
43576   void * jresult ;
43577   Dali::Path *result = 0 ;
43578
43579   {
43580     try {
43581       result = (Dali::Path *)new Dali::Path();
43582     } catch (std::out_of_range& e) {
43583       {
43584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43585       };
43586     } catch (std::exception& e) {
43587       {
43588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43589       };
43590     } catch (Dali::DaliException e) {
43591       {
43592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43593       };
43594     } catch (...) {
43595       {
43596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43597       };
43598     }
43599   }
43600
43601   jresult = (void *)result;
43602   return jresult;
43603 }
43604
43605
43606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43607   Dali::Path *arg1 = (Dali::Path *) 0 ;
43608
43609   arg1 = (Dali::Path *)jarg1;
43610   {
43611     try {
43612       delete arg1;
43613     } catch (std::out_of_range& e) {
43614       {
43615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43616       };
43617     } catch (std::exception& e) {
43618       {
43619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43620       };
43621     } catch (Dali::DaliException e) {
43622       {
43623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43624       };
43625     } catch (...) {
43626       {
43627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43628       };
43629     }
43630   }
43631
43632 }
43633
43634
43635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43636   void * jresult ;
43637   Dali::Path *arg1 = 0 ;
43638   Dali::Path *result = 0 ;
43639
43640   arg1 = (Dali::Path *)jarg1;
43641   if (!arg1) {
43642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43643     return 0;
43644   }
43645   {
43646     try {
43647       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43648     } catch (std::out_of_range& e) {
43649       {
43650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43651       };
43652     } catch (std::exception& e) {
43653       {
43654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43655       };
43656     } catch (Dali::DaliException e) {
43657       {
43658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43659       };
43660     } catch (...) {
43661       {
43662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43663       };
43664     }
43665   }
43666
43667   jresult = (void *)result;
43668   return jresult;
43669 }
43670
43671
43672 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43673   void * jresult ;
43674   Dali::Path *arg1 = (Dali::Path *) 0 ;
43675   Dali::Path *arg2 = 0 ;
43676   Dali::Path *result = 0 ;
43677
43678   arg1 = (Dali::Path *)jarg1;
43679   arg2 = (Dali::Path *)jarg2;
43680   if (!arg2) {
43681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43682     return 0;
43683   }
43684   {
43685     try {
43686       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
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_AddPoint(void * jarg1, void * jarg2) {
43712   Dali::Path *arg1 = (Dali::Path *) 0 ;
43713   Dali::Vector3 *arg2 = 0 ;
43714
43715   arg1 = (Dali::Path *)jarg1;
43716   arg2 = (Dali::Vector3 *)jarg2;
43717   if (!arg2) {
43718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43719     return ;
43720   }
43721   {
43722     try {
43723       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43724     } catch (std::out_of_range& e) {
43725       {
43726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43727       };
43728     } catch (std::exception& e) {
43729       {
43730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43731       };
43732     } catch (Dali::DaliException e) {
43733       {
43734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43735       };
43736     } catch (...) {
43737       {
43738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43739       };
43740     }
43741   }
43742
43743 }
43744
43745
43746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43747   Dali::Path *arg1 = (Dali::Path *) 0 ;
43748   Dali::Vector3 *arg2 = 0 ;
43749
43750   arg1 = (Dali::Path *)jarg1;
43751   arg2 = (Dali::Vector3 *)jarg2;
43752   if (!arg2) {
43753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43754     return ;
43755   }
43756   {
43757     try {
43758       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43759     } catch (std::out_of_range& e) {
43760       {
43761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43762       };
43763     } catch (std::exception& e) {
43764       {
43765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43766       };
43767     } catch (Dali::DaliException e) {
43768       {
43769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43770       };
43771     } catch (...) {
43772       {
43773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43774       };
43775     }
43776   }
43777
43778 }
43779
43780
43781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43782   Dali::Path *arg1 = (Dali::Path *) 0 ;
43783   float arg2 ;
43784
43785   arg1 = (Dali::Path *)jarg1;
43786   arg2 = (float)jarg2;
43787   {
43788     try {
43789       (arg1)->GenerateControlPoints(arg2);
43790     } catch (std::out_of_range& e) {
43791       {
43792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43793       };
43794     } catch (std::exception& e) {
43795       {
43796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43797       };
43798     } catch (Dali::DaliException e) {
43799       {
43800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43801       };
43802     } catch (...) {
43803       {
43804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43805       };
43806     }
43807   }
43808
43809 }
43810
43811
43812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43813   Dali::Path *arg1 = (Dali::Path *) 0 ;
43814   float arg2 ;
43815   Dali::Vector3 *arg3 = 0 ;
43816   Dali::Vector3 *arg4 = 0 ;
43817
43818   arg1 = (Dali::Path *)jarg1;
43819   arg2 = (float)jarg2;
43820   arg3 = (Dali::Vector3 *)jarg3;
43821   if (!arg3) {
43822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43823     return ;
43824   }
43825   arg4 = (Dali::Vector3 *)jarg4;
43826   if (!arg4) {
43827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43828     return ;
43829   }
43830   {
43831     try {
43832       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43833     } catch (std::out_of_range& e) {
43834       {
43835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43836       };
43837     } catch (std::exception& e) {
43838       {
43839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43840       };
43841     } catch (Dali::DaliException e) {
43842       {
43843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43844       };
43845     } catch (...) {
43846       {
43847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43848       };
43849     }
43850   }
43851
43852 }
43853
43854
43855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43856   void * jresult ;
43857   Dali::Path *arg1 = (Dali::Path *) 0 ;
43858   size_t arg2 ;
43859   Dali::Vector3 *result = 0 ;
43860
43861   arg1 = (Dali::Path *)jarg1;
43862   arg2 = (size_t)jarg2;
43863   {
43864     try {
43865       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43866     } catch (std::out_of_range& e) {
43867       {
43868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43869       };
43870     } catch (std::exception& e) {
43871       {
43872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43873       };
43874     } catch (Dali::DaliException e) {
43875       {
43876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43877       };
43878     } catch (...) {
43879       {
43880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43881       };
43882     }
43883   }
43884
43885   jresult = (void *)result;
43886   return jresult;
43887 }
43888
43889
43890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43891   void * jresult ;
43892   Dali::Path *arg1 = (Dali::Path *) 0 ;
43893   size_t arg2 ;
43894   Dali::Vector3 *result = 0 ;
43895
43896   arg1 = (Dali::Path *)jarg1;
43897   arg2 = (size_t)jarg2;
43898   {
43899     try {
43900       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43901     } catch (std::out_of_range& e) {
43902       {
43903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43904       };
43905     } catch (std::exception& e) {
43906       {
43907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43908       };
43909     } catch (Dali::DaliException e) {
43910       {
43911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43912       };
43913     } catch (...) {
43914       {
43915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43916       };
43917     }
43918   }
43919
43920   jresult = (void *)result;
43921   return jresult;
43922 }
43923
43924
43925 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43926   unsigned long jresult ;
43927   Dali::Path *arg1 = (Dali::Path *) 0 ;
43928   size_t result;
43929
43930   arg1 = (Dali::Path *)jarg1;
43931   {
43932     try {
43933       result = ((Dali::Path const *)arg1)->GetPointCount();
43934     } catch (std::out_of_range& e) {
43935       {
43936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43937       };
43938     } catch (std::exception& e) {
43939       {
43940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43941       };
43942     } catch (Dali::DaliException e) {
43943       {
43944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43945       };
43946     } catch (...) {
43947       {
43948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43949       };
43950     }
43951   }
43952
43953   jresult = (unsigned long)result;
43954   return jresult;
43955 }
43956
43957
43958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43959   void * jresult ;
43960   float arg1 ;
43961   Dali::TimePeriod *result = 0 ;
43962
43963   arg1 = (float)jarg1;
43964   {
43965     try {
43966       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43967     } catch (std::out_of_range& e) {
43968       {
43969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43970       };
43971     } catch (std::exception& e) {
43972       {
43973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43974       };
43975     } catch (Dali::DaliException e) {
43976       {
43977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43978       };
43979     } catch (...) {
43980       {
43981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43982       };
43983     }
43984   }
43985
43986   jresult = (void *)result;
43987   return jresult;
43988 }
43989
43990
43991 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43992   void * jresult ;
43993   float arg1 ;
43994   float arg2 ;
43995   Dali::TimePeriod *result = 0 ;
43996
43997   arg1 = (float)jarg1;
43998   arg2 = (float)jarg2;
43999   {
44000     try {
44001       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44002     } catch (std::out_of_range& e) {
44003       {
44004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44005       };
44006     } catch (std::exception& e) {
44007       {
44008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44009       };
44010     } catch (Dali::DaliException e) {
44011       {
44012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44013       };
44014     } catch (...) {
44015       {
44016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44017       };
44018     }
44019   }
44020
44021   jresult = (void *)result;
44022   return jresult;
44023 }
44024
44025
44026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44027   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44028
44029   arg1 = (Dali::TimePeriod *)jarg1;
44030   {
44031     try {
44032       delete arg1;
44033     } catch (std::out_of_range& e) {
44034       {
44035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44036       };
44037     } catch (std::exception& e) {
44038       {
44039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44040       };
44041     } catch (Dali::DaliException e) {
44042       {
44043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44044       };
44045     } catch (...) {
44046       {
44047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44048       };
44049     }
44050   }
44051
44052 }
44053
44054
44055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44056   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44057   float arg2 ;
44058
44059   arg1 = (Dali::TimePeriod *)jarg1;
44060   arg2 = (float)jarg2;
44061   if (arg1) (arg1)->delaySeconds = arg2;
44062 }
44063
44064
44065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44066   float jresult ;
44067   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44068   float result;
44069
44070   arg1 = (Dali::TimePeriod *)jarg1;
44071   result = (float) ((arg1)->delaySeconds);
44072   jresult = result;
44073   return jresult;
44074 }
44075
44076
44077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44078   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44079   float arg2 ;
44080
44081   arg1 = (Dali::TimePeriod *)jarg1;
44082   arg2 = (float)jarg2;
44083   if (arg1) (arg1)->durationSeconds = arg2;
44084 }
44085
44086
44087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44088   float jresult ;
44089   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44090   float result;
44091
44092   arg1 = (Dali::TimePeriod *)jarg1;
44093   result = (float) ((arg1)->durationSeconds);
44094   jresult = result;
44095   return jresult;
44096 }
44097
44098 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44099   int jresult ;
44100   int result;
44101
44102   result = (int)Dali::LinearConstrainer::Property::VALUE;
44103   jresult = (int)result;
44104   return jresult;
44105 }
44106
44107
44108 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44109   int jresult ;
44110   int result;
44111
44112   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44113   jresult = (int)result;
44114   return jresult;
44115 }
44116
44117
44118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44119   void * jresult ;
44120   Dali::LinearConstrainer::Property *result = 0 ;
44121
44122   {
44123     try {
44124       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44125     } catch (std::out_of_range& e) {
44126       {
44127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44128       };
44129     } catch (std::exception& e) {
44130       {
44131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44132       };
44133     } catch (Dali::DaliException e) {
44134       {
44135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44136       };
44137     } catch (...) {
44138       {
44139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44140       };
44141     }
44142   }
44143
44144   jresult = (void *)result;
44145   return jresult;
44146 }
44147
44148
44149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44150   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44151
44152   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44153   {
44154     try {
44155       delete arg1;
44156     } catch (std::out_of_range& e) {
44157       {
44158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44159       };
44160     } catch (std::exception& e) {
44161       {
44162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44163       };
44164     } catch (Dali::DaliException e) {
44165       {
44166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44167       };
44168     } catch (...) {
44169       {
44170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44171       };
44172     }
44173   }
44174
44175 }
44176
44177
44178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44179   void * jresult ;
44180   Dali::LinearConstrainer result;
44181
44182   {
44183     try {
44184       result = Dali::LinearConstrainer::New();
44185     } catch (std::out_of_range& e) {
44186       {
44187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44188       };
44189     } catch (std::exception& e) {
44190       {
44191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44192       };
44193     } catch (Dali::DaliException e) {
44194       {
44195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44196       };
44197     } catch (...) {
44198       {
44199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44200       };
44201     }
44202   }
44203
44204   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44205   return jresult;
44206 }
44207
44208
44209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44210   void * jresult ;
44211   Dali::BaseHandle arg1 ;
44212   Dali::BaseHandle *argp1 ;
44213   Dali::LinearConstrainer result;
44214
44215   argp1 = (Dali::BaseHandle *)jarg1;
44216   if (!argp1) {
44217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44218     return 0;
44219   }
44220   arg1 = *argp1;
44221   {
44222     try {
44223       result = Dali::LinearConstrainer::DownCast(arg1);
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_new_LinearConstrainer__SWIG_0() {
44249   void * jresult ;
44250   Dali::LinearConstrainer *result = 0 ;
44251
44252   {
44253     try {
44254       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44255     } catch (std::out_of_range& e) {
44256       {
44257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44258       };
44259     } catch (std::exception& e) {
44260       {
44261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44262       };
44263     } catch (Dali::DaliException e) {
44264       {
44265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44266       };
44267     } catch (...) {
44268       {
44269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44270       };
44271     }
44272   }
44273
44274   jresult = (void *)result;
44275   return jresult;
44276 }
44277
44278
44279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44280   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44281
44282   arg1 = (Dali::LinearConstrainer *)jarg1;
44283   {
44284     try {
44285       delete arg1;
44286     } catch (std::out_of_range& e) {
44287       {
44288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44289       };
44290     } catch (std::exception& e) {
44291       {
44292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44293       };
44294     } catch (Dali::DaliException e) {
44295       {
44296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44297       };
44298     } catch (...) {
44299       {
44300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44301       };
44302     }
44303   }
44304
44305 }
44306
44307
44308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44309   void * jresult ;
44310   Dali::LinearConstrainer *arg1 = 0 ;
44311   Dali::LinearConstrainer *result = 0 ;
44312
44313   arg1 = (Dali::LinearConstrainer *)jarg1;
44314   if (!arg1) {
44315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44316     return 0;
44317   }
44318   {
44319     try {
44320       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44321     } catch (std::out_of_range& e) {
44322       {
44323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44324       };
44325     } catch (std::exception& e) {
44326       {
44327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44328       };
44329     } catch (Dali::DaliException e) {
44330       {
44331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44332       };
44333     } catch (...) {
44334       {
44335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44336       };
44337     }
44338   }
44339
44340   jresult = (void *)result;
44341   return jresult;
44342 }
44343
44344
44345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44346   void * jresult ;
44347   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44348   Dali::LinearConstrainer *arg2 = 0 ;
44349   Dali::LinearConstrainer *result = 0 ;
44350
44351   arg1 = (Dali::LinearConstrainer *)jarg1;
44352   arg2 = (Dali::LinearConstrainer *)jarg2;
44353   if (!arg2) {
44354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44355     return 0;
44356   }
44357   {
44358     try {
44359       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
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_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44385   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44386   SwigValueWrapper< Dali::Property > arg2 ;
44387   SwigValueWrapper< Dali::Property > arg3 ;
44388   Dali::Vector2 *arg4 = 0 ;
44389   Dali::Vector2 *arg5 = 0 ;
44390   Dali::Property *argp2 ;
44391   Dali::Property *argp3 ;
44392
44393   arg1 = (Dali::LinearConstrainer *)jarg1;
44394   argp2 = (Dali::Property *)jarg2;
44395   if (!argp2) {
44396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44397     return ;
44398   }
44399   arg2 = *argp2;
44400   argp3 = (Dali::Property *)jarg3;
44401   if (!argp3) {
44402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44403     return ;
44404   }
44405   arg3 = *argp3;
44406   arg4 = (Dali::Vector2 *)jarg4;
44407   if (!arg4) {
44408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44409     return ;
44410   }
44411   arg5 = (Dali::Vector2 *)jarg5;
44412   if (!arg5) {
44413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44414     return ;
44415   }
44416   {
44417     try {
44418       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44419     } catch (std::out_of_range& e) {
44420       {
44421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44422       };
44423     } catch (std::exception& e) {
44424       {
44425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44426       };
44427     } catch (Dali::DaliException e) {
44428       {
44429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44430       };
44431     } catch (...) {
44432       {
44433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44434       };
44435     }
44436   }
44437
44438 }
44439
44440
44441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44442   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44443   SwigValueWrapper< Dali::Property > arg2 ;
44444   SwigValueWrapper< Dali::Property > arg3 ;
44445   Dali::Vector2 *arg4 = 0 ;
44446   Dali::Property *argp2 ;
44447   Dali::Property *argp3 ;
44448
44449   arg1 = (Dali::LinearConstrainer *)jarg1;
44450   argp2 = (Dali::Property *)jarg2;
44451   if (!argp2) {
44452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44453     return ;
44454   }
44455   arg2 = *argp2;
44456   argp3 = (Dali::Property *)jarg3;
44457   if (!argp3) {
44458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44459     return ;
44460   }
44461   arg3 = *argp3;
44462   arg4 = (Dali::Vector2 *)jarg4;
44463   if (!arg4) {
44464     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44465     return ;
44466   }
44467   {
44468     try {
44469       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44470     } catch (std::out_of_range& e) {
44471       {
44472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44473       };
44474     } catch (std::exception& e) {
44475       {
44476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44477       };
44478     } catch (Dali::DaliException e) {
44479       {
44480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44481       };
44482     } catch (...) {
44483       {
44484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44485       };
44486     }
44487   }
44488
44489 }
44490
44491
44492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44493   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44494   Dali::Handle *arg2 = 0 ;
44495
44496   arg1 = (Dali::LinearConstrainer *)jarg1;
44497   arg2 = (Dali::Handle *)jarg2;
44498   if (!arg2) {
44499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44500     return ;
44501   }
44502   {
44503     try {
44504       (arg1)->Remove(*arg2);
44505     } catch (std::out_of_range& e) {
44506       {
44507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44508       };
44509     } catch (std::exception& e) {
44510       {
44511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44512       };
44513     } catch (Dali::DaliException e) {
44514       {
44515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44516       };
44517     } catch (...) {
44518       {
44519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44520       };
44521     }
44522   }
44523
44524 }
44525
44526
44527 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44528   int jresult ;
44529   int result;
44530
44531   result = (int)Dali::PathConstrainer::Property::FORWARD;
44532   jresult = (int)result;
44533   return jresult;
44534 }
44535
44536
44537 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44538   int jresult ;
44539   int result;
44540
44541   result = (int)Dali::PathConstrainer::Property::POINTS;
44542   jresult = (int)result;
44543   return jresult;
44544 }
44545
44546
44547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44548   int jresult ;
44549   int result;
44550
44551   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44552   jresult = (int)result;
44553   return jresult;
44554 }
44555
44556
44557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44558   void * jresult ;
44559   Dali::PathConstrainer::Property *result = 0 ;
44560
44561   {
44562     try {
44563       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44564     } catch (std::out_of_range& e) {
44565       {
44566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44567       };
44568     } catch (std::exception& e) {
44569       {
44570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44571       };
44572     } catch (Dali::DaliException e) {
44573       {
44574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44575       };
44576     } catch (...) {
44577       {
44578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44579       };
44580     }
44581   }
44582
44583   jresult = (void *)result;
44584   return jresult;
44585 }
44586
44587
44588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44589   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44590
44591   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44592   {
44593     try {
44594       delete arg1;
44595     } catch (std::out_of_range& e) {
44596       {
44597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44598       };
44599     } catch (std::exception& e) {
44600       {
44601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44602       };
44603     } catch (Dali::DaliException e) {
44604       {
44605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44606       };
44607     } catch (...) {
44608       {
44609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44610       };
44611     }
44612   }
44613
44614 }
44615
44616
44617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44618   void * jresult ;
44619   Dali::PathConstrainer result;
44620
44621   {
44622     try {
44623       result = Dali::PathConstrainer::New();
44624     } catch (std::out_of_range& e) {
44625       {
44626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44627       };
44628     } catch (std::exception& e) {
44629       {
44630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44631       };
44632     } catch (Dali::DaliException e) {
44633       {
44634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44635       };
44636     } catch (...) {
44637       {
44638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44639       };
44640     }
44641   }
44642
44643   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44644   return jresult;
44645 }
44646
44647
44648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44649   void * jresult ;
44650   Dali::BaseHandle arg1 ;
44651   Dali::BaseHandle *argp1 ;
44652   Dali::PathConstrainer result;
44653
44654   argp1 = (Dali::BaseHandle *)jarg1;
44655   if (!argp1) {
44656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44657     return 0;
44658   }
44659   arg1 = *argp1;
44660   {
44661     try {
44662       result = Dali::PathConstrainer::DownCast(arg1);
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_new_PathConstrainer__SWIG_0() {
44688   void * jresult ;
44689   Dali::PathConstrainer *result = 0 ;
44690
44691   {
44692     try {
44693       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44694     } catch (std::out_of_range& e) {
44695       {
44696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44697       };
44698     } catch (std::exception& e) {
44699       {
44700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44701       };
44702     } catch (Dali::DaliException e) {
44703       {
44704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44705       };
44706     } catch (...) {
44707       {
44708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44709       };
44710     }
44711   }
44712
44713   jresult = (void *)result;
44714   return jresult;
44715 }
44716
44717
44718 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44719   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44720
44721   arg1 = (Dali::PathConstrainer *)jarg1;
44722   {
44723     try {
44724       delete arg1;
44725     } catch (std::out_of_range& e) {
44726       {
44727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44728       };
44729     } catch (std::exception& e) {
44730       {
44731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44732       };
44733     } catch (Dali::DaliException e) {
44734       {
44735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44736       };
44737     } catch (...) {
44738       {
44739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44740       };
44741     }
44742   }
44743
44744 }
44745
44746
44747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44748   void * jresult ;
44749   Dali::PathConstrainer *arg1 = 0 ;
44750   Dali::PathConstrainer *result = 0 ;
44751
44752   arg1 = (Dali::PathConstrainer *)jarg1;
44753   if (!arg1) {
44754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44755     return 0;
44756   }
44757   {
44758     try {
44759       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44760     } catch (std::out_of_range& e) {
44761       {
44762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44763       };
44764     } catch (std::exception& e) {
44765       {
44766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44767       };
44768     } catch (Dali::DaliException e) {
44769       {
44770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44771       };
44772     } catch (...) {
44773       {
44774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44775       };
44776     }
44777   }
44778
44779   jresult = (void *)result;
44780   return jresult;
44781 }
44782
44783
44784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44785   void * jresult ;
44786   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44787   Dali::PathConstrainer *arg2 = 0 ;
44788   Dali::PathConstrainer *result = 0 ;
44789
44790   arg1 = (Dali::PathConstrainer *)jarg1;
44791   arg2 = (Dali::PathConstrainer *)jarg2;
44792   if (!arg2) {
44793     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44794     return 0;
44795   }
44796   {
44797     try {
44798       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
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_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44824   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44825   SwigValueWrapper< Dali::Property > arg2 ;
44826   SwigValueWrapper< Dali::Property > arg3 ;
44827   Dali::Vector2 *arg4 = 0 ;
44828   Dali::Vector2 *arg5 = 0 ;
44829   Dali::Property *argp2 ;
44830   Dali::Property *argp3 ;
44831
44832   arg1 = (Dali::PathConstrainer *)jarg1;
44833   argp2 = (Dali::Property *)jarg2;
44834   if (!argp2) {
44835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44836     return ;
44837   }
44838   arg2 = *argp2;
44839   argp3 = (Dali::Property *)jarg3;
44840   if (!argp3) {
44841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44842     return ;
44843   }
44844   arg3 = *argp3;
44845   arg4 = (Dali::Vector2 *)jarg4;
44846   if (!arg4) {
44847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44848     return ;
44849   }
44850   arg5 = (Dali::Vector2 *)jarg5;
44851   if (!arg5) {
44852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44853     return ;
44854   }
44855   {
44856     try {
44857       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44858     } catch (std::out_of_range& e) {
44859       {
44860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44861       };
44862     } catch (std::exception& e) {
44863       {
44864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44865       };
44866     } catch (Dali::DaliException e) {
44867       {
44868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44869       };
44870     } catch (...) {
44871       {
44872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44873       };
44874     }
44875   }
44876
44877 }
44878
44879
44880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44881   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44882   SwigValueWrapper< Dali::Property > arg2 ;
44883   SwigValueWrapper< Dali::Property > arg3 ;
44884   Dali::Vector2 *arg4 = 0 ;
44885   Dali::Property *argp2 ;
44886   Dali::Property *argp3 ;
44887
44888   arg1 = (Dali::PathConstrainer *)jarg1;
44889   argp2 = (Dali::Property *)jarg2;
44890   if (!argp2) {
44891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44892     return ;
44893   }
44894   arg2 = *argp2;
44895   argp3 = (Dali::Property *)jarg3;
44896   if (!argp3) {
44897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44898     return ;
44899   }
44900   arg3 = *argp3;
44901   arg4 = (Dali::Vector2 *)jarg4;
44902   if (!arg4) {
44903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44904     return ;
44905   }
44906   {
44907     try {
44908       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44909     } catch (std::out_of_range& e) {
44910       {
44911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44912       };
44913     } catch (std::exception& e) {
44914       {
44915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44916       };
44917     } catch (Dali::DaliException e) {
44918       {
44919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44920       };
44921     } catch (...) {
44922       {
44923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44924       };
44925     }
44926   }
44927
44928 }
44929
44930
44931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44932   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44933   Dali::Handle *arg2 = 0 ;
44934
44935   arg1 = (Dali::PathConstrainer *)jarg1;
44936   arg2 = (Dali::Handle *)jarg2;
44937   if (!arg2) {
44938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44939     return ;
44940   }
44941   {
44942     try {
44943       (arg1)->Remove(*arg2);
44944     } catch (std::out_of_range& e) {
44945       {
44946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44947       };
44948     } catch (std::exception& e) {
44949       {
44950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44951       };
44952     } catch (Dali::DaliException e) {
44953       {
44954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44955       };
44956     } catch (...) {
44957       {
44958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44959       };
44960     }
44961   }
44962
44963 }
44964
44965
44966 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44967   int jresult ;
44968   Dali::FittingMode::Type result;
44969
44970   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44971   jresult = (int)result;
44972   return jresult;
44973 }
44974
44975
44976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44977   int jresult ;
44978   Dali::SamplingMode::Type result;
44979
44980   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44981   jresult = (int)result;
44982   return jresult;
44983 }
44984
44985
44986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_0() {
44987   void * jresult ;
44988   Dali::BufferImage *result = 0 ;
44989
44990   {
44991     try {
44992       result = (Dali::BufferImage *)new Dali::BufferImage();
44993     } catch (std::out_of_range& e) {
44994       {
44995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44996       };
44997     } catch (std::exception& e) {
44998       {
44999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45000       };
45001     } catch (Dali::DaliException e) {
45002       {
45003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45004       };
45005     } catch (...) {
45006       {
45007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45008       };
45009     }
45010   }
45011
45012   jresult = (void *)result;
45013   return jresult;
45014 }
45015
45016
45017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3) {
45018   void * jresult ;
45019   unsigned int arg1 ;
45020   unsigned int arg2 ;
45021   Dali::Pixel::Format arg3 ;
45022   Dali::BufferImage result;
45023
45024   arg1 = (unsigned int)jarg1;
45025   arg2 = (unsigned int)jarg2;
45026   arg3 = (Dali::Pixel::Format)jarg3;
45027   {
45028     try {
45029       result = Dali::BufferImage::New(arg1,arg2,arg3);
45030     } catch (std::out_of_range& e) {
45031       {
45032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45033       };
45034     } catch (std::exception& e) {
45035       {
45036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45037       };
45038     } catch (Dali::DaliException e) {
45039       {
45040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45041       };
45042     } catch (...) {
45043       {
45044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45045       };
45046     }
45047   }
45048
45049   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45050   return jresult;
45051 }
45052
45053
45054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
45055   void * jresult ;
45056   unsigned int arg1 ;
45057   unsigned int arg2 ;
45058   Dali::BufferImage result;
45059
45060   arg1 = (unsigned int)jarg1;
45061   arg2 = (unsigned int)jarg2;
45062   {
45063     try {
45064       result = Dali::BufferImage::New(arg1,arg2);
45065     } catch (std::out_of_range& e) {
45066       {
45067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45068       };
45069     } catch (std::exception& e) {
45070       {
45071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45072       };
45073     } catch (Dali::DaliException e) {
45074       {
45075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45076       };
45077     } catch (...) {
45078       {
45079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45080       };
45081     }
45082   }
45083
45084   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45085   return jresult;
45086 }
45087
45088
45089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_2(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4, unsigned int jarg5) {
45090   void * jresult ;
45091   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45092   unsigned int arg2 ;
45093   unsigned int arg3 ;
45094   Dali::Pixel::Format arg4 ;
45095   unsigned int arg5 ;
45096   Dali::BufferImage result;
45097
45098   arg1 = jarg1;
45099   arg2 = (unsigned int)jarg2;
45100   arg3 = (unsigned int)jarg3;
45101   arg4 = (Dali::Pixel::Format)jarg4;
45102   arg5 = (unsigned int)jarg5;
45103   {
45104     try {
45105       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4,arg5);
45106     } catch (std::out_of_range& e) {
45107       {
45108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45109       };
45110     } catch (std::exception& e) {
45111       {
45112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45113       };
45114     } catch (Dali::DaliException e) {
45115       {
45116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45117       };
45118     } catch (...) {
45119       {
45120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45121       };
45122     }
45123   }
45124
45125   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45126
45127
45128   return jresult;
45129 }
45130
45131
45132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_3(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, int jarg4) {
45133   void * jresult ;
45134   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45135   unsigned int arg2 ;
45136   unsigned int arg3 ;
45137   Dali::Pixel::Format arg4 ;
45138   Dali::BufferImage result;
45139
45140   arg1 = jarg1;
45141   arg2 = (unsigned int)jarg2;
45142   arg3 = (unsigned int)jarg3;
45143   arg4 = (Dali::Pixel::Format)jarg4;
45144   {
45145     try {
45146       result = Dali::BufferImage::New(arg1,arg2,arg3,arg4);
45147     } catch (std::out_of_range& e) {
45148       {
45149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45150       };
45151     } catch (std::exception& e) {
45152       {
45153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45154       };
45155     } catch (Dali::DaliException e) {
45156       {
45157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45158       };
45159     } catch (...) {
45160       {
45161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45162       };
45163     }
45164   }
45165
45166   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45167
45168
45169   return jresult;
45170 }
45171
45172
45173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_New__SWIG_4(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3) {
45174   void * jresult ;
45175   Dali::PixelBuffer *arg1 = (Dali::PixelBuffer *) 0 ;
45176   unsigned int arg2 ;
45177   unsigned int arg3 ;
45178   Dali::BufferImage result;
45179
45180   arg1 = jarg1;
45181   arg2 = (unsigned int)jarg2;
45182   arg3 = (unsigned int)jarg3;
45183   {
45184     try {
45185       result = Dali::BufferImage::New(arg1,arg2,arg3);
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_DownCast(void * jarg1) {
45213   void * jresult ;
45214   Dali::BaseHandle arg1 ;
45215   Dali::BaseHandle *argp1 ;
45216   Dali::BufferImage result;
45217
45218   argp1 = (Dali::BaseHandle *)jarg1;
45219   if (!argp1) {
45220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45221     return 0;
45222   }
45223   arg1 = *argp1;
45224   {
45225     try {
45226       result = Dali::BufferImage::DownCast(arg1);
45227     } catch (std::out_of_range& e) {
45228       {
45229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45230       };
45231     } catch (std::exception& e) {
45232       {
45233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45234       };
45235     } catch (Dali::DaliException e) {
45236       {
45237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45238       };
45239     } catch (...) {
45240       {
45241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45242       };
45243     }
45244   }
45245
45246   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45247   return jresult;
45248 }
45249
45250
45251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BufferImage(void * jarg1) {
45252   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45253
45254   arg1 = (Dali::BufferImage *)jarg1;
45255   {
45256     try {
45257       delete arg1;
45258     } catch (std::out_of_range& e) {
45259       {
45260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45261       };
45262     } catch (std::exception& e) {
45263       {
45264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45265       };
45266     } catch (Dali::DaliException e) {
45267       {
45268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45269       };
45270     } catch (...) {
45271       {
45272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45273       };
45274     }
45275   }
45276
45277 }
45278
45279
45280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BufferImage__SWIG_1(void * jarg1) {
45281   void * jresult ;
45282   Dali::BufferImage *arg1 = 0 ;
45283   Dali::BufferImage *result = 0 ;
45284
45285   arg1 = (Dali::BufferImage *)jarg1;
45286   if (!arg1) {
45287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45288     return 0;
45289   }
45290   {
45291     try {
45292       result = (Dali::BufferImage *)new Dali::BufferImage((Dali::BufferImage const &)*arg1);
45293     } catch (std::out_of_range& e) {
45294       {
45295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45296       };
45297     } catch (std::exception& e) {
45298       {
45299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45300       };
45301     } catch (Dali::DaliException e) {
45302       {
45303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45304       };
45305     } catch (...) {
45306       {
45307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45308       };
45309     }
45310   }
45311
45312   jresult = (void *)result;
45313   return jresult;
45314 }
45315
45316
45317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_Assign(void * jarg1, void * jarg2) {
45318   void * jresult ;
45319   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45320   Dali::BufferImage *arg2 = 0 ;
45321   Dali::BufferImage *result = 0 ;
45322
45323   arg1 = (Dali::BufferImage *)jarg1;
45324   arg2 = (Dali::BufferImage *)jarg2;
45325   if (!arg2) {
45326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BufferImage const & type is null", 0);
45327     return 0;
45328   }
45329   {
45330     try {
45331       result = (Dali::BufferImage *) &(arg1)->operator =((Dali::BufferImage const &)*arg2);
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_WHITE() {
45357   void * jresult ;
45358   Dali::BufferImage result;
45359
45360   {
45361     try {
45362       result = Dali::BufferImage::WHITE();
45363     } catch (std::out_of_range& e) {
45364       {
45365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45366       };
45367     } catch (std::exception& e) {
45368       {
45369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45370       };
45371     } catch (Dali::DaliException e) {
45372       {
45373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45374       };
45375     } catch (...) {
45376       {
45377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45378       };
45379     }
45380   }
45381
45382   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
45383   return jresult;
45384 }
45385
45386
45387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BufferImage_GetBuffer(void * jarg1) {
45388   void * jresult ;
45389   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45390   Dali::PixelBuffer *result = 0 ;
45391
45392   arg1 = (Dali::BufferImage *)jarg1;
45393   {
45394     try {
45395       result = (Dali::PixelBuffer *)(arg1)->GetBuffer();
45396     } catch (std::out_of_range& e) {
45397       {
45398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45399       };
45400     } catch (std::exception& e) {
45401       {
45402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45403       };
45404     } catch (Dali::DaliException e) {
45405       {
45406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45407       };
45408     } catch (...) {
45409       {
45410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45411       };
45412     }
45413   }
45414
45415   jresult = (void *)result;
45416   return jresult;
45417 }
45418
45419
45420 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferSize(void * jarg1) {
45421   unsigned int jresult ;
45422   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45423   unsigned int result;
45424
45425   arg1 = (Dali::BufferImage *)jarg1;
45426   {
45427     try {
45428       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferSize();
45429     } catch (std::out_of_range& e) {
45430       {
45431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45432       };
45433     } catch (std::exception& e) {
45434       {
45435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45436       };
45437     } catch (Dali::DaliException e) {
45438       {
45439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45440       };
45441     } catch (...) {
45442       {
45443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45444       };
45445     }
45446   }
45447
45448   jresult = result;
45449   return jresult;
45450 }
45451
45452
45453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_GetBufferStride(void * jarg1) {
45454   unsigned int jresult ;
45455   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45456   unsigned int result;
45457
45458   arg1 = (Dali::BufferImage *)jarg1;
45459   {
45460     try {
45461       result = (unsigned int)((Dali::BufferImage const *)arg1)->GetBufferStride();
45462     } catch (std::out_of_range& e) {
45463       {
45464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45465       };
45466     } catch (std::exception& e) {
45467       {
45468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45469       };
45470     } catch (Dali::DaliException e) {
45471       {
45472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45473       };
45474     } catch (...) {
45475       {
45476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45477       };
45478     }
45479   }
45480
45481   jresult = result;
45482   return jresult;
45483 }
45484
45485
45486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BufferImage_GetPixelFormat(void * jarg1) {
45487   int jresult ;
45488   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45489   Dali::Pixel::Format result;
45490
45491   arg1 = (Dali::BufferImage *)jarg1;
45492   {
45493     try {
45494       result = (Dali::Pixel::Format)((Dali::BufferImage const *)arg1)->GetPixelFormat();
45495     } catch (std::out_of_range& e) {
45496       {
45497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45498       };
45499     } catch (std::exception& e) {
45500       {
45501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45502       };
45503     } catch (Dali::DaliException e) {
45504       {
45505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45506       };
45507     } catch (...) {
45508       {
45509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45510       };
45511     }
45512   }
45513
45514   jresult = (int)result;
45515   return jresult;
45516 }
45517
45518
45519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_0(void * jarg1) {
45520   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45521
45522   arg1 = (Dali::BufferImage *)jarg1;
45523   {
45524     try {
45525       (arg1)->Update();
45526     } catch (std::out_of_range& e) {
45527       {
45528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45529       };
45530     } catch (std::exception& e) {
45531       {
45532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45533       };
45534     } catch (Dali::DaliException e) {
45535       {
45536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45537       };
45538     } catch (...) {
45539       {
45540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45541       };
45542     }
45543   }
45544
45545 }
45546
45547
45548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BufferImage_Update__SWIG_1(void * jarg1, void * jarg2) {
45549   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45550   SwigValueWrapper< Dali::Rect< unsigned int > > arg2 ;
45551   Dali::RectArea *argp2 ;
45552
45553   arg1 = (Dali::BufferImage *)jarg1;
45554   argp2 = (Dali::RectArea *)jarg2;
45555   if (!argp2) {
45556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RectArea", 0);
45557     return ;
45558   }
45559   arg2 = *argp2;
45560   {
45561     try {
45562       (arg1)->Update(arg2);
45563     } catch (std::out_of_range& e) {
45564       {
45565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45566       };
45567     } catch (std::exception& e) {
45568       {
45569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45570       };
45571     } catch (Dali::DaliException e) {
45572       {
45573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45574       };
45575     } catch (...) {
45576       {
45577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45578       };
45579     }
45580   }
45581
45582 }
45583
45584
45585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BufferImage_IsDataExternal(void * jarg1) {
45586   unsigned int jresult ;
45587   Dali::BufferImage *arg1 = (Dali::BufferImage *) 0 ;
45588   bool result;
45589
45590   arg1 = (Dali::BufferImage *)jarg1;
45591   {
45592     try {
45593       result = (bool)((Dali::BufferImage const *)arg1)->IsDataExternal();
45594     } catch (std::out_of_range& e) {
45595       {
45596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45597       };
45598     } catch (std::exception& e) {
45599       {
45600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45601       };
45602     } catch (Dali::DaliException e) {
45603       {
45604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45605       };
45606     } catch (...) {
45607       {
45608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45609       };
45610     }
45611   }
45612
45613   jresult = result;
45614   return jresult;
45615 }
45616
45617
45618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_0() {
45619   void * jresult ;
45620   Dali::EncodedBufferImage *result = 0 ;
45621
45622   {
45623     try {
45624       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage();
45625     } catch (std::out_of_range& e) {
45626       {
45627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45628       };
45629     } catch (std::exception& e) {
45630       {
45631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45632       };
45633     } catch (Dali::DaliException e) {
45634       {
45635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45636       };
45637     } catch (...) {
45638       {
45639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45640       };
45641     }
45642   }
45643
45644   jresult = (void *)result;
45645   return jresult;
45646 }
45647
45648
45649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_0(void * jarg1, unsigned long jarg2) {
45650   void * jresult ;
45651   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45652   std::size_t arg2 ;
45653   Dali::EncodedBufferImage result;
45654
45655   arg1 = (uint8_t *)jarg1;
45656   arg2 = (std::size_t)jarg2;
45657   {
45658     try {
45659       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2);
45660     } catch (std::out_of_range& e) {
45661       {
45662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45663       };
45664     } catch (std::exception& e) {
45665       {
45666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45667       };
45668     } catch (Dali::DaliException e) {
45669       {
45670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45671       };
45672     } catch (...) {
45673       {
45674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45675       };
45676     }
45677   }
45678
45679   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45680   return jresult;
45681 }
45682
45683
45684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
45685   void * jresult ;
45686   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45687   std::size_t arg2 ;
45688   Dali::ImageDimensions arg3 ;
45689   Dali::FittingMode::Type arg4 ;
45690   Dali::SamplingMode::Type arg5 ;
45691   bool arg6 ;
45692   Dali::ImageDimensions *argp3 ;
45693   Dali::EncodedBufferImage result;
45694
45695   arg1 = (uint8_t *)jarg1;
45696   arg2 = (std::size_t)jarg2;
45697   argp3 = (Dali::ImageDimensions *)jarg3;
45698   if (!argp3) {
45699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45700     return 0;
45701   }
45702   arg3 = *argp3;
45703   arg4 = (Dali::FittingMode::Type)jarg4;
45704   arg5 = (Dali::SamplingMode::Type)jarg5;
45705   arg6 = jarg6 ? true : false;
45706   {
45707     try {
45708       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5,arg6);
45709     } catch (std::out_of_range& e) {
45710       {
45711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45712       };
45713     } catch (std::exception& e) {
45714       {
45715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45716       };
45717     } catch (Dali::DaliException e) {
45718       {
45719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45720       };
45721     } catch (...) {
45722       {
45723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45724       };
45725     }
45726   }
45727
45728   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45729   return jresult;
45730 }
45731
45732
45733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_New__SWIG_2(void * jarg1, unsigned long jarg2, void * jarg3, int jarg4, int jarg5) {
45734   void * jresult ;
45735   uint8_t *arg1 = (uint8_t *) (uint8_t *)0 ;
45736   std::size_t arg2 ;
45737   Dali::ImageDimensions arg3 ;
45738   Dali::FittingMode::Type arg4 ;
45739   Dali::SamplingMode::Type arg5 ;
45740   Dali::ImageDimensions *argp3 ;
45741   Dali::EncodedBufferImage result;
45742
45743   arg1 = (uint8_t *)jarg1;
45744   arg2 = (std::size_t)jarg2;
45745   argp3 = (Dali::ImageDimensions *)jarg3;
45746   if (!argp3) {
45747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45748     return 0;
45749   }
45750   arg3 = *argp3;
45751   arg4 = (Dali::FittingMode::Type)jarg4;
45752   arg5 = (Dali::SamplingMode::Type)jarg5;
45753   {
45754     try {
45755       result = Dali::EncodedBufferImage::New((uint8_t const *)arg1,arg2,arg3,arg4,arg5);
45756     } catch (std::out_of_range& e) {
45757       {
45758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45759       };
45760     } catch (std::exception& e) {
45761       {
45762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45763       };
45764     } catch (Dali::DaliException e) {
45765       {
45766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45767       };
45768     } catch (...) {
45769       {
45770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45771       };
45772     }
45773   }
45774
45775   jresult = new Dali::EncodedBufferImage((const Dali::EncodedBufferImage &)result);
45776   return jresult;
45777 }
45778
45779
45780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_DownCast(void * jarg1) {
45781   void * jresult ;
45782   Dali::BaseHandle arg1 ;
45783   Dali::BaseHandle *argp1 ;
45784   Dali::EncodedBufferImage result;
45785
45786   argp1 = (Dali::BaseHandle *)jarg1;
45787   if (!argp1) {
45788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45789     return 0;
45790   }
45791   arg1 = *argp1;
45792   {
45793     try {
45794       result = Dali::EncodedBufferImage::DownCast(arg1);
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_delete_EncodedBufferImage(void * jarg1) {
45820   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45821
45822   arg1 = (Dali::EncodedBufferImage *)jarg1;
45823   {
45824     try {
45825       delete arg1;
45826     } catch (std::out_of_range& e) {
45827       {
45828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45829       };
45830     } catch (std::exception& e) {
45831       {
45832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45833       };
45834     } catch (Dali::DaliException e) {
45835       {
45836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45837       };
45838     } catch (...) {
45839       {
45840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45841       };
45842     }
45843   }
45844
45845 }
45846
45847
45848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_EncodedBufferImage__SWIG_1(void * jarg1) {
45849   void * jresult ;
45850   Dali::EncodedBufferImage *arg1 = 0 ;
45851   Dali::EncodedBufferImage *result = 0 ;
45852
45853   arg1 = (Dali::EncodedBufferImage *)jarg1;
45854   if (!arg1) {
45855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45856     return 0;
45857   }
45858   {
45859     try {
45860       result = (Dali::EncodedBufferImage *)new Dali::EncodedBufferImage((Dali::EncodedBufferImage const &)*arg1);
45861     } catch (std::out_of_range& e) {
45862       {
45863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45864       };
45865     } catch (std::exception& e) {
45866       {
45867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45868       };
45869     } catch (Dali::DaliException e) {
45870       {
45871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45872       };
45873     } catch (...) {
45874       {
45875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45876       };
45877     }
45878   }
45879
45880   jresult = (void *)result;
45881   return jresult;
45882 }
45883
45884
45885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_Assign(void * jarg1, void * jarg2) {
45886   void * jresult ;
45887   Dali::EncodedBufferImage *arg1 = (Dali::EncodedBufferImage *) 0 ;
45888   Dali::EncodedBufferImage *arg2 = 0 ;
45889   Dali::EncodedBufferImage *result = 0 ;
45890
45891   arg1 = (Dali::EncodedBufferImage *)jarg1;
45892   arg2 = (Dali::EncodedBufferImage *)jarg2;
45893   if (!arg2) {
45894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::EncodedBufferImage const & type is null", 0);
45895     return 0;
45896   }
45897   {
45898     try {
45899       result = (Dali::EncodedBufferImage *) &(arg1)->operator =((Dali::EncodedBufferImage const &)*arg2);
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_new_NativeImage__SWIG_0() {
45925   void * jresult ;
45926   Dali::NativeImage *result = 0 ;
45927
45928   {
45929     try {
45930       result = (Dali::NativeImage *)new Dali::NativeImage();
45931     } catch (std::out_of_range& e) {
45932       {
45933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45934       };
45935     } catch (std::exception& e) {
45936       {
45937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45938       };
45939     } catch (Dali::DaliException e) {
45940       {
45941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45942       };
45943     } catch (...) {
45944       {
45945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45946       };
45947     }
45948   }
45949
45950   jresult = (void *)result;
45951   return jresult;
45952 }
45953
45954
45955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45956   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45957
45958   arg1 = (Dali::NativeImage *)jarg1;
45959   {
45960     try {
45961       delete arg1;
45962     } catch (std::out_of_range& e) {
45963       {
45964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45965       };
45966     } catch (std::exception& e) {
45967       {
45968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45969       };
45970     } catch (Dali::DaliException e) {
45971       {
45972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45973       };
45974     } catch (...) {
45975       {
45976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45977       };
45978     }
45979   }
45980
45981 }
45982
45983
45984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45985   void * jresult ;
45986   Dali::NativeImage *arg1 = 0 ;
45987   Dali::NativeImage *result = 0 ;
45988
45989   arg1 = (Dali::NativeImage *)jarg1;
45990   if (!arg1) {
45991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45992     return 0;
45993   }
45994   {
45995     try {
45996       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
45997     } catch (std::out_of_range& e) {
45998       {
45999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46000       };
46001     } catch (std::exception& e) {
46002       {
46003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46004       };
46005     } catch (Dali::DaliException e) {
46006       {
46007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46008       };
46009     } catch (...) {
46010       {
46011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46012       };
46013     }
46014   }
46015
46016   jresult = (void *)result;
46017   return jresult;
46018 }
46019
46020
46021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
46022   void * jresult ;
46023   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46024   Dali::NativeImage *arg2 = 0 ;
46025   Dali::NativeImage *result = 0 ;
46026
46027   arg1 = (Dali::NativeImage *)jarg1;
46028   arg2 = (Dali::NativeImage *)jarg2;
46029   if (!arg2) {
46030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
46031     return 0;
46032   }
46033   {
46034     try {
46035       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
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_CreateGlTexture(void * jarg1) {
46061   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46062
46063   arg1 = (Dali::NativeImage *)jarg1;
46064   {
46065     try {
46066       (arg1)->CreateGlTexture();
46067     } catch (std::out_of_range& e) {
46068       {
46069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46070       };
46071     } catch (std::exception& e) {
46072       {
46073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46074       };
46075     } catch (Dali::DaliException e) {
46076       {
46077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46078       };
46079     } catch (...) {
46080       {
46081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46082       };
46083     }
46084   }
46085
46086 }
46087
46088
46089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
46090   void * jresult ;
46091   NativeImageInterface *arg1 = 0 ;
46092   Dali::NativeImage result;
46093
46094   arg1 = (NativeImageInterface *)jarg1;
46095   if (!arg1) {
46096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
46097     return 0;
46098   }
46099   {
46100     try {
46101       result = Dali::NativeImage::New(*arg1);
46102     } catch (std::out_of_range& e) {
46103       {
46104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46105       };
46106     } catch (std::exception& e) {
46107       {
46108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46109       };
46110     } catch (Dali::DaliException e) {
46111       {
46112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46113       };
46114     } catch (...) {
46115       {
46116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46117       };
46118     }
46119   }
46120
46121   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
46122   return jresult;
46123 }
46124
46125
46126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
46127   void * jresult ;
46128   Dali::BaseHandle arg1 ;
46129   Dali::BaseHandle *argp1 ;
46130   Dali::NativeImage result;
46131
46132   argp1 = (Dali::BaseHandle *)jarg1;
46133   if (!argp1) {
46134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46135     return 0;
46136   }
46137   arg1 = *argp1;
46138   {
46139     try {
46140       result = Dali::NativeImage::DownCast(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 char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
46166   char * jresult ;
46167   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46168   char *result = 0 ;
46169
46170   arg1 = (Dali::NativeImage *)jarg1;
46171   {
46172     try {
46173       result = (char *)(arg1)->GetCustomFragmentPreFix();
46174     } catch (std::out_of_range& e) {
46175       {
46176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46177       };
46178     } catch (std::exception& e) {
46179       {
46180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46181       };
46182     } catch (Dali::DaliException e) {
46183       {
46184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46185       };
46186     } catch (...) {
46187       {
46188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46189       };
46190     }
46191   }
46192
46193   jresult = SWIG_csharp_string_callback((const char *)result);
46194   return jresult;
46195 }
46196
46197
46198 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
46199   char * jresult ;
46200   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
46201   char *result = 0 ;
46202
46203   arg1 = (Dali::NativeImage *)jarg1;
46204   {
46205     try {
46206       result = (char *)(arg1)->GetCustomSamplerTypename();
46207     } catch (std::out_of_range& e) {
46208       {
46209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46210       };
46211     } catch (std::exception& e) {
46212       {
46213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46214       };
46215     } catch (Dali::DaliException e) {
46216       {
46217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46218       };
46219     } catch (...) {
46220       {
46221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46222       };
46223     }
46224   }
46225
46226   jresult = SWIG_csharp_string_callback((const char *)result);
46227   return jresult;
46228 }
46229
46230
46231 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
46232   unsigned int jresult ;
46233   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46234   bool result;
46235
46236   arg1 = (Dali::NativeImageInterface *)jarg1;
46237   {
46238     try {
46239       result = (bool)(arg1)->GlExtensionCreate();
46240     } catch (std::out_of_range& e) {
46241       {
46242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46243       };
46244     } catch (std::exception& e) {
46245       {
46246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46247       };
46248     } catch (Dali::DaliException e) {
46249       {
46250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46251       };
46252     } catch (...) {
46253       {
46254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46255       };
46256     }
46257   }
46258
46259   jresult = result;
46260   return jresult;
46261 }
46262
46263
46264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
46265   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46266
46267   arg1 = (Dali::NativeImageInterface *)jarg1;
46268   {
46269     try {
46270       (arg1)->GlExtensionDestroy();
46271     } catch (std::out_of_range& e) {
46272       {
46273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46274       };
46275     } catch (std::exception& e) {
46276       {
46277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46278       };
46279     } catch (Dali::DaliException e) {
46280       {
46281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46282       };
46283     } catch (...) {
46284       {
46285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46286       };
46287     }
46288   }
46289
46290 }
46291
46292
46293 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
46294   unsigned int jresult ;
46295   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46296   unsigned int result;
46297
46298   arg1 = (Dali::NativeImageInterface *)jarg1;
46299   {
46300     try {
46301       result = (unsigned int)(arg1)->TargetTexture();
46302     } catch (std::out_of_range& e) {
46303       {
46304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46305       };
46306     } catch (std::exception& e) {
46307       {
46308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46309       };
46310     } catch (Dali::DaliException e) {
46311       {
46312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46313       };
46314     } catch (...) {
46315       {
46316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46317       };
46318     }
46319   }
46320
46321   jresult = result;
46322   return jresult;
46323 }
46324
46325
46326 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
46327   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46328
46329   arg1 = (Dali::NativeImageInterface *)jarg1;
46330   {
46331     try {
46332       (arg1)->PrepareTexture();
46333     } catch (std::out_of_range& e) {
46334       {
46335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46336       };
46337     } catch (std::exception& e) {
46338       {
46339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46340       };
46341     } catch (Dali::DaliException e) {
46342       {
46343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46344       };
46345     } catch (...) {
46346       {
46347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46348       };
46349     }
46350   }
46351
46352 }
46353
46354
46355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
46356   unsigned int jresult ;
46357   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46358   unsigned int result;
46359
46360   arg1 = (Dali::NativeImageInterface *)jarg1;
46361   {
46362     try {
46363       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
46364     } catch (std::out_of_range& e) {
46365       {
46366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46367       };
46368     } catch (std::exception& e) {
46369       {
46370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46371       };
46372     } catch (Dali::DaliException e) {
46373       {
46374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46375       };
46376     } catch (...) {
46377       {
46378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46379       };
46380     }
46381   }
46382
46383   jresult = result;
46384   return jresult;
46385 }
46386
46387
46388 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
46389   unsigned int jresult ;
46390   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46391   unsigned int result;
46392
46393   arg1 = (Dali::NativeImageInterface *)jarg1;
46394   {
46395     try {
46396       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
46397     } catch (std::out_of_range& e) {
46398       {
46399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46400       };
46401     } catch (std::exception& e) {
46402       {
46403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46404       };
46405     } catch (Dali::DaliException e) {
46406       {
46407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46408       };
46409     } catch (...) {
46410       {
46411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46412       };
46413     }
46414   }
46415
46416   jresult = result;
46417   return jresult;
46418 }
46419
46420
46421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
46422   unsigned int jresult ;
46423   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
46424   bool result;
46425
46426   arg1 = (Dali::NativeImageInterface *)jarg1;
46427   {
46428     try {
46429       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
46430     } catch (std::out_of_range& e) {
46431       {
46432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46433       };
46434     } catch (std::exception& e) {
46435       {
46436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46437       };
46438     } catch (Dali::DaliException e) {
46439       {
46440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46441       };
46442     } catch (...) {
46443       {
46444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46445       };
46446     }
46447   }
46448
46449   jresult = result;
46450   return jresult;
46451 }
46452
46453
46454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
46455   void * jresult ;
46456   std::string *arg1 = 0 ;
46457   Dali::ImageDimensions result;
46458
46459   if (!jarg1) {
46460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46461     return 0;
46462   }
46463   std::string arg1_str(jarg1);
46464   arg1 = &arg1_str;
46465   {
46466     try {
46467       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
46468     } catch (std::out_of_range& e) {
46469       {
46470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46471       };
46472     } catch (std::exception& e) {
46473       {
46474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46475       };
46476     } catch (Dali::DaliException e) {
46477       {
46478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46479       };
46480     } catch (...) {
46481       {
46482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46483       };
46484     }
46485   }
46486
46487   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
46488
46489   //argout typemap for const std::string&
46490
46491   return jresult;
46492 }
46493
46494
46495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
46496   void * jresult ;
46497   Dali::ResourceImage *result = 0 ;
46498
46499   {
46500     try {
46501       result = (Dali::ResourceImage *)new Dali::ResourceImage();
46502     } catch (std::out_of_range& e) {
46503       {
46504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46505       };
46506     } catch (std::exception& e) {
46507       {
46508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46509       };
46510     } catch (Dali::DaliException e) {
46511       {
46512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46513       };
46514     } catch (...) {
46515       {
46516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46517       };
46518     }
46519   }
46520
46521   jresult = (void *)result;
46522   return jresult;
46523 }
46524
46525
46526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
46527   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46528
46529   arg1 = (Dali::ResourceImage *)jarg1;
46530   {
46531     try {
46532       delete arg1;
46533     } catch (std::out_of_range& e) {
46534       {
46535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46536       };
46537     } catch (std::exception& e) {
46538       {
46539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46540       };
46541     } catch (Dali::DaliException e) {
46542       {
46543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46544       };
46545     } catch (...) {
46546       {
46547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46548       };
46549     }
46550   }
46551
46552 }
46553
46554
46555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
46556   void * jresult ;
46557   Dali::ResourceImage *arg1 = 0 ;
46558   Dali::ResourceImage *result = 0 ;
46559
46560   arg1 = (Dali::ResourceImage *)jarg1;
46561   if (!arg1) {
46562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46563     return 0;
46564   }
46565   {
46566     try {
46567       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
46568     } catch (std::out_of_range& e) {
46569       {
46570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46571       };
46572     } catch (std::exception& e) {
46573       {
46574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46575       };
46576     } catch (Dali::DaliException e) {
46577       {
46578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46579       };
46580     } catch (...) {
46581       {
46582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46583       };
46584     }
46585   }
46586
46587   jresult = (void *)result;
46588   return jresult;
46589 }
46590
46591
46592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
46593   void * jresult ;
46594   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46595   Dali::ResourceImage *arg2 = 0 ;
46596   Dali::ResourceImage *result = 0 ;
46597
46598   arg1 = (Dali::ResourceImage *)jarg1;
46599   arg2 = (Dali::ResourceImage *)jarg2;
46600   if (!arg2) {
46601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
46602     return 0;
46603   }
46604   {
46605     try {
46606       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
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_New__SWIG_0(char * jarg1, unsigned int jarg2) {
46632   void * jresult ;
46633   std::string *arg1 = 0 ;
46634   bool arg2 ;
46635   Dali::ResourceImage result;
46636
46637   if (!jarg1) {
46638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46639     return 0;
46640   }
46641   std::string arg1_str(jarg1);
46642   arg1 = &arg1_str;
46643   arg2 = jarg2 ? true : false;
46644   {
46645     try {
46646       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46647     } catch (std::out_of_range& e) {
46648       {
46649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46650       };
46651     } catch (std::exception& e) {
46652       {
46653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46654       };
46655     } catch (Dali::DaliException e) {
46656       {
46657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46658       };
46659     } catch (...) {
46660       {
46661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46662       };
46663     }
46664   }
46665
46666   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46667
46668   //argout typemap for const std::string&
46669
46670   return jresult;
46671 }
46672
46673
46674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
46675   void * jresult ;
46676   std::string *arg1 = 0 ;
46677   Dali::ResourceImage result;
46678
46679   if (!jarg1) {
46680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46681     return 0;
46682   }
46683   std::string arg1_str(jarg1);
46684   arg1 = &arg1_str;
46685   {
46686     try {
46687       result = Dali::ResourceImage::New((std::string const &)*arg1);
46688     } catch (std::out_of_range& e) {
46689       {
46690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46691       };
46692     } catch (std::exception& e) {
46693       {
46694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46695       };
46696     } catch (Dali::DaliException e) {
46697       {
46698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46699       };
46700     } catch (...) {
46701       {
46702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46703       };
46704     }
46705   }
46706
46707   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46708
46709   //argout typemap for const std::string&
46710
46711   return jresult;
46712 }
46713
46714
46715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
46716   void * jresult ;
46717   std::string *arg1 = 0 ;
46718   Dali::ImageDimensions arg2 ;
46719   Dali::FittingMode::Type arg3 ;
46720   Dali::SamplingMode::Type arg4 ;
46721   bool arg5 ;
46722   Dali::ImageDimensions *argp2 ;
46723   Dali::ResourceImage result;
46724
46725   if (!jarg1) {
46726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46727     return 0;
46728   }
46729   std::string arg1_str(jarg1);
46730   arg1 = &arg1_str;
46731   argp2 = (Dali::ImageDimensions *)jarg2;
46732   if (!argp2) {
46733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46734     return 0;
46735   }
46736   arg2 = *argp2;
46737   arg3 = (Dali::FittingMode::Type)jarg3;
46738   arg4 = (Dali::SamplingMode::Type)jarg4;
46739   arg5 = jarg5 ? true : false;
46740   {
46741     try {
46742       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
46743     } catch (std::out_of_range& e) {
46744       {
46745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46746       };
46747     } catch (std::exception& e) {
46748       {
46749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46750       };
46751     } catch (Dali::DaliException e) {
46752       {
46753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46754       };
46755     } catch (...) {
46756       {
46757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46758       };
46759     }
46760   }
46761
46762   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46763
46764   //argout typemap for const std::string&
46765
46766   return jresult;
46767 }
46768
46769
46770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46771   void * jresult ;
46772   std::string *arg1 = 0 ;
46773   Dali::ImageDimensions arg2 ;
46774   Dali::FittingMode::Type arg3 ;
46775   Dali::SamplingMode::Type arg4 ;
46776   Dali::ImageDimensions *argp2 ;
46777   Dali::ResourceImage result;
46778
46779   if (!jarg1) {
46780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46781     return 0;
46782   }
46783   std::string arg1_str(jarg1);
46784   arg1 = &arg1_str;
46785   argp2 = (Dali::ImageDimensions *)jarg2;
46786   if (!argp2) {
46787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46788     return 0;
46789   }
46790   arg2 = *argp2;
46791   arg3 = (Dali::FittingMode::Type)jarg3;
46792   arg4 = (Dali::SamplingMode::Type)jarg4;
46793   {
46794     try {
46795       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46796     } catch (std::out_of_range& e) {
46797       {
46798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46799       };
46800     } catch (std::exception& e) {
46801       {
46802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46803       };
46804     } catch (Dali::DaliException e) {
46805       {
46806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46807       };
46808     } catch (...) {
46809       {
46810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46811       };
46812     }
46813   }
46814
46815   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46816
46817   //argout typemap for const std::string&
46818
46819   return jresult;
46820 }
46821
46822
46823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46824   void * jresult ;
46825   std::string *arg1 = 0 ;
46826   Dali::ImageDimensions arg2 ;
46827   Dali::FittingMode::Type arg3 ;
46828   Dali::ImageDimensions *argp2 ;
46829   Dali::ResourceImage result;
46830
46831   if (!jarg1) {
46832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46833     return 0;
46834   }
46835   std::string arg1_str(jarg1);
46836   arg1 = &arg1_str;
46837   argp2 = (Dali::ImageDimensions *)jarg2;
46838   if (!argp2) {
46839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46840     return 0;
46841   }
46842   arg2 = *argp2;
46843   arg3 = (Dali::FittingMode::Type)jarg3;
46844   {
46845     try {
46846       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46847     } catch (std::out_of_range& e) {
46848       {
46849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46850       };
46851     } catch (std::exception& e) {
46852       {
46853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46854       };
46855     } catch (Dali::DaliException e) {
46856       {
46857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46858       };
46859     } catch (...) {
46860       {
46861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46862       };
46863     }
46864   }
46865
46866   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46867
46868   //argout typemap for const std::string&
46869
46870   return jresult;
46871 }
46872
46873
46874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46875   void * jresult ;
46876   std::string *arg1 = 0 ;
46877   Dali::ImageDimensions arg2 ;
46878   Dali::ImageDimensions *argp2 ;
46879   Dali::ResourceImage result;
46880
46881   if (!jarg1) {
46882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46883     return 0;
46884   }
46885   std::string arg1_str(jarg1);
46886   arg1 = &arg1_str;
46887   argp2 = (Dali::ImageDimensions *)jarg2;
46888   if (!argp2) {
46889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46890     return 0;
46891   }
46892   arg2 = *argp2;
46893   {
46894     try {
46895       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46896     } catch (std::out_of_range& e) {
46897       {
46898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46899       };
46900     } catch (std::exception& e) {
46901       {
46902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46903       };
46904     } catch (Dali::DaliException e) {
46905       {
46906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46907       };
46908     } catch (...) {
46909       {
46910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46911       };
46912     }
46913   }
46914
46915   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46916
46917   //argout typemap for const std::string&
46918
46919   return jresult;
46920 }
46921
46922
46923 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46924   void * jresult ;
46925   Dali::BaseHandle arg1 ;
46926   Dali::BaseHandle *argp1 ;
46927   Dali::ResourceImage result;
46928
46929   argp1 = (Dali::BaseHandle *)jarg1;
46930   if (!argp1) {
46931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46932     return 0;
46933   }
46934   arg1 = *argp1;
46935   {
46936     try {
46937       result = Dali::ResourceImage::DownCast(arg1);
46938     } catch (std::out_of_range& e) {
46939       {
46940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46941       };
46942     } catch (std::exception& e) {
46943       {
46944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46945       };
46946     } catch (Dali::DaliException e) {
46947       {
46948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46949       };
46950     } catch (...) {
46951       {
46952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46953       };
46954     }
46955   }
46956
46957   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46958   return jresult;
46959 }
46960
46961
46962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46963   int jresult ;
46964   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46965   Dali::LoadingState result;
46966
46967   arg1 = (Dali::ResourceImage *)jarg1;
46968   {
46969     try {
46970       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46971     } catch (std::out_of_range& e) {
46972       {
46973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46974       };
46975     } catch (std::exception& e) {
46976       {
46977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46978       };
46979     } catch (Dali::DaliException e) {
46980       {
46981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46982       };
46983     } catch (...) {
46984       {
46985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46986       };
46987     }
46988   }
46989
46990   jresult = (int)result;
46991   return jresult;
46992 }
46993
46994
46995 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
46996   char * jresult ;
46997   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46998   std::string result;
46999
47000   arg1 = (Dali::ResourceImage *)jarg1;
47001   {
47002     try {
47003       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
47004     } catch (std::out_of_range& e) {
47005       {
47006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47007       };
47008     } catch (std::exception& e) {
47009       {
47010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47011       };
47012     } catch (Dali::DaliException e) {
47013       {
47014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47015       };
47016     } catch (...) {
47017       {
47018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47019       };
47020     }
47021   }
47022
47023   jresult = SWIG_csharp_string_callback((&result)->c_str());
47024   return jresult;
47025 }
47026
47027
47028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
47029   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47030
47031   arg1 = (Dali::ResourceImage *)jarg1;
47032   {
47033     try {
47034       (arg1)->Reload();
47035     } catch (std::out_of_range& e) {
47036       {
47037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47038       };
47039     } catch (std::exception& e) {
47040       {
47041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47042       };
47043     } catch (Dali::DaliException e) {
47044       {
47045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47046       };
47047     } catch (...) {
47048       {
47049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47050       };
47051     }
47052   }
47053
47054 }
47055
47056
47057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
47058   void * jresult ;
47059   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
47060   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
47061
47062   arg1 = (Dali::ResourceImage *)jarg1;
47063   {
47064     try {
47065       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
47066     } catch (std::out_of_range& e) {
47067       {
47068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47069       };
47070     } catch (std::exception& e) {
47071       {
47072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47073       };
47074     } catch (Dali::DaliException e) {
47075       {
47076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47077       };
47078     } catch (...) {
47079       {
47080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47081       };
47082     }
47083   }
47084
47085   jresult = (void *)result;
47086   return jresult;
47087 }
47088
47089
47090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
47091   void * jresult ;
47092   Dali::FrameBufferImage *result = 0 ;
47093
47094   {
47095     try {
47096       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
47097     } catch (std::out_of_range& e) {
47098       {
47099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47100       };
47101     } catch (std::exception& e) {
47102       {
47103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47104       };
47105     } catch (Dali::DaliException e) {
47106       {
47107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47108       };
47109     } catch (...) {
47110       {
47111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47112       };
47113     }
47114   }
47115
47116   jresult = (void *)result;
47117   return jresult;
47118 }
47119
47120
47121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
47122   void * jresult ;
47123   unsigned int arg1 ;
47124   unsigned int arg2 ;
47125   Dali::Pixel::Format arg3 ;
47126   Dali::RenderBuffer::Format arg4 ;
47127   Dali::FrameBufferImage result;
47128
47129   arg1 = (unsigned int)jarg1;
47130   arg2 = (unsigned int)jarg2;
47131   arg3 = (Dali::Pixel::Format)jarg3;
47132   arg4 = (Dali::RenderBuffer::Format)jarg4;
47133   {
47134     try {
47135       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
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 = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47156   return jresult;
47157 }
47158
47159
47160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
47161   void * jresult ;
47162   unsigned int arg1 ;
47163   unsigned int arg2 ;
47164   Dali::Pixel::Format arg3 ;
47165   Dali::FrameBufferImage result;
47166
47167   arg1 = (unsigned int)jarg1;
47168   arg2 = (unsigned int)jarg2;
47169   arg3 = (Dali::Pixel::Format)jarg3;
47170   {
47171     try {
47172       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
47173     } catch (std::out_of_range& e) {
47174       {
47175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47176       };
47177     } catch (std::exception& e) {
47178       {
47179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47180       };
47181     } catch (Dali::DaliException e) {
47182       {
47183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47184       };
47185     } catch (...) {
47186       {
47187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47188       };
47189     }
47190   }
47191
47192   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47193   return jresult;
47194 }
47195
47196
47197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
47198   void * jresult ;
47199   unsigned int arg1 ;
47200   unsigned int arg2 ;
47201   Dali::FrameBufferImage result;
47202
47203   arg1 = (unsigned int)jarg1;
47204   arg2 = (unsigned int)jarg2;
47205   {
47206     try {
47207       result = Dali::FrameBufferImage::New(arg1,arg2);
47208     } catch (std::out_of_range& e) {
47209       {
47210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47211       };
47212     } catch (std::exception& e) {
47213       {
47214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47215       };
47216     } catch (Dali::DaliException e) {
47217       {
47218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47219       };
47220     } catch (...) {
47221       {
47222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47223       };
47224     }
47225   }
47226
47227   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47228   return jresult;
47229 }
47230
47231
47232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
47233   void * jresult ;
47234   unsigned int arg1 ;
47235   Dali::FrameBufferImage result;
47236
47237   arg1 = (unsigned int)jarg1;
47238   {
47239     try {
47240       result = Dali::FrameBufferImage::New(arg1);
47241     } catch (std::out_of_range& e) {
47242       {
47243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47244       };
47245     } catch (std::exception& e) {
47246       {
47247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47248       };
47249     } catch (Dali::DaliException e) {
47250       {
47251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47252       };
47253     } catch (...) {
47254       {
47255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47256       };
47257     }
47258   }
47259
47260   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47261   return jresult;
47262 }
47263
47264
47265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
47266   void * jresult ;
47267   Dali::FrameBufferImage result;
47268
47269   {
47270     try {
47271       result = Dali::FrameBufferImage::New();
47272     } catch (std::out_of_range& e) {
47273       {
47274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47275       };
47276     } catch (std::exception& e) {
47277       {
47278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47279       };
47280     } catch (Dali::DaliException e) {
47281       {
47282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47283       };
47284     } catch (...) {
47285       {
47286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47287       };
47288     }
47289   }
47290
47291   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47292   return jresult;
47293 }
47294
47295
47296 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
47297   void * jresult ;
47298   Dali::NativeImageInterface *arg1 = 0 ;
47299   Dali::FrameBufferImage result;
47300
47301   arg1 = (Dali::NativeImageInterface *)jarg1;
47302   if (!arg1) {
47303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
47304     return 0;
47305   }
47306   {
47307     try {
47308       result = Dali::FrameBufferImage::New(*arg1);
47309     } catch (std::out_of_range& e) {
47310       {
47311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47312       };
47313     } catch (std::exception& e) {
47314       {
47315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47316       };
47317     } catch (Dali::DaliException e) {
47318       {
47319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47320       };
47321     } catch (...) {
47322       {
47323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47324       };
47325     }
47326   }
47327
47328   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
47329   return jresult;
47330 }
47331
47332
47333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
47334   void * jresult ;
47335   Dali::BaseHandle arg1 ;
47336   Dali::BaseHandle *argp1 ;
47337   Dali::FrameBufferImage result;
47338
47339   argp1 = (Dali::BaseHandle *)jarg1;
47340   if (!argp1) {
47341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47342     return 0;
47343   }
47344   arg1 = *argp1;
47345   {
47346     try {
47347       result = Dali::FrameBufferImage::DownCast(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_delete_FrameBufferImage(void * jarg1) {
47373   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47374
47375   arg1 = (Dali::FrameBufferImage *)jarg1;
47376   {
47377     try {
47378       delete arg1;
47379     } catch (std::out_of_range& e) {
47380       {
47381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47382       };
47383     } catch (std::exception& e) {
47384       {
47385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47386       };
47387     } catch (Dali::DaliException e) {
47388       {
47389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47390       };
47391     } catch (...) {
47392       {
47393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47394       };
47395     }
47396   }
47397
47398 }
47399
47400
47401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
47402   void * jresult ;
47403   Dali::FrameBufferImage *arg1 = 0 ;
47404   Dali::FrameBufferImage *result = 0 ;
47405
47406   arg1 = (Dali::FrameBufferImage *)jarg1;
47407   if (!arg1) {
47408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47409     return 0;
47410   }
47411   {
47412     try {
47413       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
47414     } catch (std::out_of_range& e) {
47415       {
47416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47417       };
47418     } catch (std::exception& e) {
47419       {
47420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47421       };
47422     } catch (Dali::DaliException e) {
47423       {
47424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47425       };
47426     } catch (...) {
47427       {
47428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47429       };
47430     }
47431   }
47432
47433   jresult = (void *)result;
47434   return jresult;
47435 }
47436
47437
47438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
47439   void * jresult ;
47440   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
47441   Dali::FrameBufferImage *arg2 = 0 ;
47442   Dali::FrameBufferImage *result = 0 ;
47443
47444   arg1 = (Dali::FrameBufferImage *)jarg1;
47445   arg2 = (Dali::FrameBufferImage *)jarg2;
47446   if (!arg2) {
47447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
47448     return 0;
47449   }
47450   {
47451     try {
47452       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
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_new_NinePatchImage__SWIG_0() {
47478   void * jresult ;
47479   Dali::NinePatchImage *result = 0 ;
47480
47481   {
47482     try {
47483       result = (Dali::NinePatchImage *)new Dali::NinePatchImage();
47484     } catch (std::out_of_range& e) {
47485       {
47486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47487       };
47488     } catch (std::exception& e) {
47489       {
47490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47491       };
47492     } catch (Dali::DaliException e) {
47493       {
47494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47495       };
47496     } catch (...) {
47497       {
47498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47499       };
47500     }
47501   }
47502
47503   jresult = (void *)result;
47504   return jresult;
47505 }
47506
47507
47508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_New(char * jarg1) {
47509   void * jresult ;
47510   std::string *arg1 = 0 ;
47511   Dali::NinePatchImage result;
47512
47513   if (!jarg1) {
47514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47515     return 0;
47516   }
47517   std::string arg1_str(jarg1);
47518   arg1 = &arg1_str;
47519   {
47520     try {
47521       result = Dali::NinePatchImage::New((std::string const &)*arg1);
47522     } catch (std::out_of_range& e) {
47523       {
47524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47525       };
47526     } catch (std::exception& e) {
47527       {
47528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47529       };
47530     } catch (Dali::DaliException e) {
47531       {
47532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47533       };
47534     } catch (...) {
47535       {
47536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47537       };
47538     }
47539   }
47540
47541   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47542
47543   //argout typemap for const std::string&
47544
47545   return jresult;
47546 }
47547
47548
47549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_DownCast(void * jarg1) {
47550   void * jresult ;
47551   Dali::BaseHandle arg1 ;
47552   Dali::BaseHandle *argp1 ;
47553   Dali::NinePatchImage result;
47554
47555   argp1 = (Dali::BaseHandle *)jarg1;
47556   if (!argp1) {
47557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47558     return 0;
47559   }
47560   arg1 = *argp1;
47561   {
47562     try {
47563       result = Dali::NinePatchImage::DownCast(arg1);
47564     } catch (std::out_of_range& e) {
47565       {
47566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47567       };
47568     } catch (std::exception& e) {
47569       {
47570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47571       };
47572     } catch (Dali::DaliException e) {
47573       {
47574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47575       };
47576     } catch (...) {
47577       {
47578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47579       };
47580     }
47581   }
47582
47583   jresult = new Dali::NinePatchImage((const Dali::NinePatchImage &)result);
47584   return jresult;
47585 }
47586
47587
47588 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NinePatchImage(void * jarg1) {
47589   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47590
47591   arg1 = (Dali::NinePatchImage *)jarg1;
47592   {
47593     try {
47594       delete arg1;
47595     } catch (std::out_of_range& e) {
47596       {
47597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47598       };
47599     } catch (std::exception& e) {
47600       {
47601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47602       };
47603     } catch (Dali::DaliException e) {
47604       {
47605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47606       };
47607     } catch (...) {
47608       {
47609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47610       };
47611     }
47612   }
47613
47614 }
47615
47616
47617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NinePatchImage__SWIG_1(void * jarg1) {
47618   void * jresult ;
47619   Dali::NinePatchImage *arg1 = 0 ;
47620   Dali::NinePatchImage *result = 0 ;
47621
47622   arg1 = (Dali::NinePatchImage *)jarg1;
47623   if (!arg1) {
47624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47625     return 0;
47626   }
47627   {
47628     try {
47629       result = (Dali::NinePatchImage *)new Dali::NinePatchImage((Dali::NinePatchImage const &)*arg1);
47630     } catch (std::out_of_range& e) {
47631       {
47632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47633       };
47634     } catch (std::exception& e) {
47635       {
47636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47637       };
47638     } catch (Dali::DaliException e) {
47639       {
47640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47641       };
47642     } catch (...) {
47643       {
47644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47645       };
47646     }
47647   }
47648
47649   jresult = (void *)result;
47650   return jresult;
47651 }
47652
47653
47654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_Assign(void * jarg1, void * jarg2) {
47655   void * jresult ;
47656   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47657   Dali::NinePatchImage *arg2 = 0 ;
47658   Dali::NinePatchImage *result = 0 ;
47659
47660   arg1 = (Dali::NinePatchImage *)jarg1;
47661   arg2 = (Dali::NinePatchImage *)jarg2;
47662   if (!arg2) {
47663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NinePatchImage const & type is null", 0);
47664     return 0;
47665   }
47666   {
47667     try {
47668       result = (Dali::NinePatchImage *) &(arg1)->operator =((Dali::NinePatchImage const &)*arg2);
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_GetStretchBorders(void * jarg1) {
47694   void * jresult ;
47695   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47696   Dali::Vector4 result;
47697
47698   arg1 = (Dali::NinePatchImage *)jarg1;
47699   {
47700     try {
47701       result = (arg1)->GetStretchBorders();
47702     } catch (std::out_of_range& e) {
47703       {
47704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47705       };
47706     } catch (std::exception& e) {
47707       {
47708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47709       };
47710     } catch (Dali::DaliException e) {
47711       {
47712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47713       };
47714     } catch (...) {
47715       {
47716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47717       };
47718     }
47719   }
47720
47721   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
47722   return jresult;
47723 }
47724
47725
47726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsX(void * jarg1) {
47727   void * jresult ;
47728   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47729   Dali::NinePatchImage::StretchRanges *result = 0 ;
47730
47731   arg1 = (Dali::NinePatchImage *)jarg1;
47732   {
47733     try {
47734       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsX();
47735     } catch (std::out_of_range& e) {
47736       {
47737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47738       };
47739     } catch (std::exception& e) {
47740       {
47741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47742       };
47743     } catch (Dali::DaliException e) {
47744       {
47745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47746       };
47747     } catch (...) {
47748       {
47749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47750       };
47751     }
47752   }
47753
47754   jresult = (void *)result;
47755   return jresult;
47756 }
47757
47758
47759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetStretchPixelsY(void * jarg1) {
47760   void * jresult ;
47761   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47762   Dali::NinePatchImage::StretchRanges *result = 0 ;
47763
47764   arg1 = (Dali::NinePatchImage *)jarg1;
47765   {
47766     try {
47767       result = (Dali::NinePatchImage::StretchRanges *) &(arg1)->GetStretchPixelsY();
47768     } catch (std::out_of_range& e) {
47769       {
47770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47771       };
47772     } catch (std::exception& e) {
47773       {
47774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47775       };
47776     } catch (Dali::DaliException e) {
47777       {
47778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47779       };
47780     } catch (...) {
47781       {
47782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47783       };
47784     }
47785   }
47786
47787   jresult = (void *)result;
47788   return jresult;
47789 }
47790
47791
47792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_GetChildRectangle(void * jarg1) {
47793   void * jresult ;
47794   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47795   Dali::Rect< int > result;
47796
47797   arg1 = (Dali::NinePatchImage *)jarg1;
47798   {
47799     try {
47800       result = (arg1)->GetChildRectangle();
47801     } catch (std::out_of_range& e) {
47802       {
47803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47804       };
47805     } catch (std::exception& e) {
47806       {
47807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47808       };
47809     } catch (Dali::DaliException e) {
47810       {
47811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47812       };
47813     } catch (...) {
47814       {
47815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47816       };
47817     }
47818   }
47819
47820   jresult = new Dali::Rect< int >((const Dali::Rect< int > &)result);
47821   return jresult;
47822 }
47823
47824
47825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NinePatchImage_CreateCroppedBufferImage(void * jarg1) {
47826   void * jresult ;
47827   Dali::NinePatchImage *arg1 = (Dali::NinePatchImage *) 0 ;
47828   Dali::BufferImage result;
47829
47830   arg1 = (Dali::NinePatchImage *)jarg1;
47831   {
47832     try {
47833       result = (arg1)->CreateCroppedBufferImage();
47834     } catch (std::out_of_range& e) {
47835       {
47836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47837       };
47838     } catch (std::exception& e) {
47839       {
47840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47841       };
47842     } catch (Dali::DaliException e) {
47843       {
47844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47845       };
47846     } catch (...) {
47847       {
47848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47849       };
47850     }
47851   }
47852
47853   jresult = new Dali::BufferImage((const Dali::BufferImage &)result);
47854   return jresult;
47855 }
47856
47857
47858 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NinePatchImage_IsNinePatchUrl(char * jarg1) {
47859   unsigned int jresult ;
47860   std::string *arg1 = 0 ;
47861   bool result;
47862
47863   if (!jarg1) {
47864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47865     return 0;
47866   }
47867   std::string arg1_str(jarg1);
47868   arg1 = &arg1_str;
47869   {
47870     try {
47871       result = (bool)Dali::NinePatchImage::IsNinePatchUrl((std::string const &)*arg1);
47872     } catch (std::out_of_range& e) {
47873       {
47874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47875       };
47876     } catch (std::exception& e) {
47877       {
47878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47879       };
47880     } catch (Dali::DaliException e) {
47881       {
47882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47883       };
47884     } catch (...) {
47885       {
47886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47887       };
47888     }
47889   }
47890
47891   jresult = result;
47892
47893   //argout typemap for const std::string&
47894
47895   return jresult;
47896 }
47897
47898
47899 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
47900   int jresult ;
47901   int result;
47902
47903   result = (int)Dali::CameraActor::Property::TYPE;
47904   jresult = (int)result;
47905   return jresult;
47906 }
47907
47908
47909 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
47910   int jresult ;
47911   int result;
47912
47913   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
47914   jresult = (int)result;
47915   return jresult;
47916 }
47917
47918
47919 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
47920   int jresult ;
47921   int result;
47922
47923   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
47924   jresult = (int)result;
47925   return jresult;
47926 }
47927
47928
47929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
47930   int jresult ;
47931   int result;
47932
47933   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
47934   jresult = (int)result;
47935   return jresult;
47936 }
47937
47938
47939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
47940   int jresult ;
47941   int result;
47942
47943   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
47944   jresult = (int)result;
47945   return jresult;
47946 }
47947
47948
47949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
47950   int jresult ;
47951   int result;
47952
47953   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
47954   jresult = (int)result;
47955   return jresult;
47956 }
47957
47958
47959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
47960   int jresult ;
47961   int result;
47962
47963   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
47964   jresult = (int)result;
47965   return jresult;
47966 }
47967
47968
47969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
47970   int jresult ;
47971   int result;
47972
47973   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
47974   jresult = (int)result;
47975   return jresult;
47976 }
47977
47978
47979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
47980   int jresult ;
47981   int result;
47982
47983   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
47984   jresult = (int)result;
47985   return jresult;
47986 }
47987
47988
47989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
47990   int jresult ;
47991   int result;
47992
47993   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
47994   jresult = (int)result;
47995   return jresult;
47996 }
47997
47998
47999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
48000   int jresult ;
48001   int result;
48002
48003   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
48004   jresult = (int)result;
48005   return jresult;
48006 }
48007
48008
48009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
48010   int jresult ;
48011   int result;
48012
48013   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
48014   jresult = (int)result;
48015   return jresult;
48016 }
48017
48018
48019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
48020   int jresult ;
48021   int result;
48022
48023   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
48024   jresult = (int)result;
48025   return jresult;
48026 }
48027
48028
48029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
48030   int jresult ;
48031   int result;
48032
48033   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
48034   jresult = (int)result;
48035   return jresult;
48036 }
48037
48038
48039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
48040   void * jresult ;
48041   Dali::CameraActor::Property *result = 0 ;
48042
48043   {
48044     try {
48045       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
48046     } catch (std::out_of_range& e) {
48047       {
48048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48049       };
48050     } catch (std::exception& e) {
48051       {
48052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48053       };
48054     } catch (Dali::DaliException e) {
48055       {
48056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48057       };
48058     } catch (...) {
48059       {
48060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48061       };
48062     }
48063   }
48064
48065   jresult = (void *)result;
48066   return jresult;
48067 }
48068
48069
48070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
48071   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
48072
48073   arg1 = (Dali::CameraActor::Property *)jarg1;
48074   {
48075     try {
48076       delete arg1;
48077     } catch (std::out_of_range& e) {
48078       {
48079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48080       };
48081     } catch (std::exception& e) {
48082       {
48083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48084       };
48085     } catch (Dali::DaliException e) {
48086       {
48087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48088       };
48089     } catch (...) {
48090       {
48091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48092       };
48093     }
48094   }
48095
48096 }
48097
48098
48099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
48100   void * jresult ;
48101   Dali::CameraActor *result = 0 ;
48102
48103   {
48104     try {
48105       result = (Dali::CameraActor *)new Dali::CameraActor();
48106     } catch (std::out_of_range& e) {
48107       {
48108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48109       };
48110     } catch (std::exception& e) {
48111       {
48112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48113       };
48114     } catch (Dali::DaliException e) {
48115       {
48116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48117       };
48118     } catch (...) {
48119       {
48120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48121       };
48122     }
48123   }
48124
48125   jresult = (void *)result;
48126   return jresult;
48127 }
48128
48129
48130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
48131   void * jresult ;
48132   Dali::CameraActor result;
48133
48134   {
48135     try {
48136       result = Dali::CameraActor::New();
48137     } catch (std::out_of_range& e) {
48138       {
48139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48140       };
48141     } catch (std::exception& e) {
48142       {
48143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48144       };
48145     } catch (Dali::DaliException e) {
48146       {
48147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48148       };
48149     } catch (...) {
48150       {
48151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48152       };
48153     }
48154   }
48155
48156   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48157   return jresult;
48158 }
48159
48160
48161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
48162   void * jresult ;
48163   Dali::Size *arg1 = 0 ;
48164   Dali::CameraActor result;
48165
48166   arg1 = (Dali::Size *)jarg1;
48167   if (!arg1) {
48168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48169     return 0;
48170   }
48171   {
48172     try {
48173       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
48174     } catch (std::out_of_range& e) {
48175       {
48176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48177       };
48178     } catch (std::exception& e) {
48179       {
48180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48181       };
48182     } catch (Dali::DaliException e) {
48183       {
48184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48185       };
48186     } catch (...) {
48187       {
48188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48189       };
48190     }
48191   }
48192
48193   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
48194   return jresult;
48195 }
48196
48197
48198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
48199   void * jresult ;
48200   Dali::BaseHandle arg1 ;
48201   Dali::BaseHandle *argp1 ;
48202   Dali::CameraActor result;
48203
48204   argp1 = (Dali::BaseHandle *)jarg1;
48205   if (!argp1) {
48206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
48207     return 0;
48208   }
48209   arg1 = *argp1;
48210   {
48211     try {
48212       result = Dali::CameraActor::DownCast(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_delete_CameraActor(void * jarg1) {
48238   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48239
48240   arg1 = (Dali::CameraActor *)jarg1;
48241   {
48242     try {
48243       delete arg1;
48244     } catch (std::out_of_range& e) {
48245       {
48246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48247       };
48248     } catch (std::exception& e) {
48249       {
48250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48251       };
48252     } catch (Dali::DaliException e) {
48253       {
48254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48255       };
48256     } catch (...) {
48257       {
48258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48259       };
48260     }
48261   }
48262
48263 }
48264
48265
48266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
48267   void * jresult ;
48268   Dali::CameraActor *arg1 = 0 ;
48269   Dali::CameraActor *result = 0 ;
48270
48271   arg1 = (Dali::CameraActor *)jarg1;
48272   if (!arg1) {
48273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48274     return 0;
48275   }
48276   {
48277     try {
48278       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
48279     } catch (std::out_of_range& e) {
48280       {
48281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48282       };
48283     } catch (std::exception& e) {
48284       {
48285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48286       };
48287     } catch (Dali::DaliException e) {
48288       {
48289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48290       };
48291     } catch (...) {
48292       {
48293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48294       };
48295     }
48296   }
48297
48298   jresult = (void *)result;
48299   return jresult;
48300 }
48301
48302
48303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
48304   void * jresult ;
48305   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48306   Dali::CameraActor *arg2 = 0 ;
48307   Dali::CameraActor *result = 0 ;
48308
48309   arg1 = (Dali::CameraActor *)jarg1;
48310   arg2 = (Dali::CameraActor *)jarg2;
48311   if (!arg2) {
48312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
48313     return 0;
48314   }
48315   {
48316     try {
48317       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
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_SetType(void * jarg1, int jarg2) {
48343   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48344   Dali::Camera::Type arg2 ;
48345
48346   arg1 = (Dali::CameraActor *)jarg1;
48347   arg2 = (Dali::Camera::Type)jarg2;
48348   {
48349     try {
48350       (arg1)->SetType(arg2);
48351     } catch (std::out_of_range& e) {
48352       {
48353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48354       };
48355     } catch (std::exception& e) {
48356       {
48357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48358       };
48359     } catch (Dali::DaliException e) {
48360       {
48361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48362       };
48363     } catch (...) {
48364       {
48365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48366       };
48367     }
48368   }
48369
48370 }
48371
48372
48373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
48374   int jresult ;
48375   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48376   Dali::Camera::Type result;
48377
48378   arg1 = (Dali::CameraActor *)jarg1;
48379   {
48380     try {
48381       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
48382     } catch (std::out_of_range& e) {
48383       {
48384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48385       };
48386     } catch (std::exception& e) {
48387       {
48388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48389       };
48390     } catch (Dali::DaliException e) {
48391       {
48392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48393       };
48394     } catch (...) {
48395       {
48396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48397       };
48398     }
48399   }
48400
48401   jresult = (int)result;
48402   return jresult;
48403 }
48404
48405
48406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
48407   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48408   Dali::Camera::ProjectionMode arg2 ;
48409
48410   arg1 = (Dali::CameraActor *)jarg1;
48411   arg2 = (Dali::Camera::ProjectionMode)jarg2;
48412   {
48413     try {
48414       (arg1)->SetProjectionMode(arg2);
48415     } catch (std::out_of_range& e) {
48416       {
48417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48418       };
48419     } catch (std::exception& e) {
48420       {
48421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48422       };
48423     } catch (Dali::DaliException e) {
48424       {
48425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48426       };
48427     } catch (...) {
48428       {
48429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48430       };
48431     }
48432   }
48433
48434 }
48435
48436
48437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
48438   int jresult ;
48439   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48440   Dali::Camera::ProjectionMode result;
48441
48442   arg1 = (Dali::CameraActor *)jarg1;
48443   {
48444     try {
48445       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
48446     } catch (std::out_of_range& e) {
48447       {
48448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48449       };
48450     } catch (std::exception& e) {
48451       {
48452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48453       };
48454     } catch (Dali::DaliException e) {
48455       {
48456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48457       };
48458     } catch (...) {
48459       {
48460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48461       };
48462     }
48463   }
48464
48465   jresult = (int)result;
48466   return jresult;
48467 }
48468
48469
48470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
48471   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48472   float arg2 ;
48473
48474   arg1 = (Dali::CameraActor *)jarg1;
48475   arg2 = (float)jarg2;
48476   {
48477     try {
48478       (arg1)->SetFieldOfView(arg2);
48479     } catch (std::out_of_range& e) {
48480       {
48481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48482       };
48483     } catch (std::exception& e) {
48484       {
48485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48486       };
48487     } catch (Dali::DaliException e) {
48488       {
48489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48490       };
48491     } catch (...) {
48492       {
48493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48494       };
48495     }
48496   }
48497
48498 }
48499
48500
48501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
48502   float jresult ;
48503   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48504   float result;
48505
48506   arg1 = (Dali::CameraActor *)jarg1;
48507   {
48508     try {
48509       result = (float)(arg1)->GetFieldOfView();
48510     } catch (std::out_of_range& e) {
48511       {
48512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48513       };
48514     } catch (std::exception& e) {
48515       {
48516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48517       };
48518     } catch (Dali::DaliException e) {
48519       {
48520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48521       };
48522     } catch (...) {
48523       {
48524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48525       };
48526     }
48527   }
48528
48529   jresult = result;
48530   return jresult;
48531 }
48532
48533
48534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
48535   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48536   float arg2 ;
48537
48538   arg1 = (Dali::CameraActor *)jarg1;
48539   arg2 = (float)jarg2;
48540   {
48541     try {
48542       (arg1)->SetAspectRatio(arg2);
48543     } catch (std::out_of_range& e) {
48544       {
48545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48546       };
48547     } catch (std::exception& e) {
48548       {
48549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48550       };
48551     } catch (Dali::DaliException e) {
48552       {
48553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48554       };
48555     } catch (...) {
48556       {
48557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48558       };
48559     }
48560   }
48561
48562 }
48563
48564
48565 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
48566   float jresult ;
48567   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48568   float result;
48569
48570   arg1 = (Dali::CameraActor *)jarg1;
48571   {
48572     try {
48573       result = (float)(arg1)->GetAspectRatio();
48574     } catch (std::out_of_range& e) {
48575       {
48576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48577       };
48578     } catch (std::exception& e) {
48579       {
48580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48581       };
48582     } catch (Dali::DaliException e) {
48583       {
48584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48585       };
48586     } catch (...) {
48587       {
48588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48589       };
48590     }
48591   }
48592
48593   jresult = result;
48594   return jresult;
48595 }
48596
48597
48598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
48599   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48600   float arg2 ;
48601
48602   arg1 = (Dali::CameraActor *)jarg1;
48603   arg2 = (float)jarg2;
48604   {
48605     try {
48606       (arg1)->SetNearClippingPlane(arg2);
48607     } catch (std::out_of_range& e) {
48608       {
48609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48610       };
48611     } catch (std::exception& e) {
48612       {
48613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48614       };
48615     } catch (Dali::DaliException e) {
48616       {
48617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48618       };
48619     } catch (...) {
48620       {
48621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48622       };
48623     }
48624   }
48625
48626 }
48627
48628
48629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
48630   float jresult ;
48631   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48632   float result;
48633
48634   arg1 = (Dali::CameraActor *)jarg1;
48635   {
48636     try {
48637       result = (float)(arg1)->GetNearClippingPlane();
48638     } catch (std::out_of_range& e) {
48639       {
48640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48641       };
48642     } catch (std::exception& e) {
48643       {
48644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48645       };
48646     } catch (Dali::DaliException e) {
48647       {
48648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48649       };
48650     } catch (...) {
48651       {
48652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48653       };
48654     }
48655   }
48656
48657   jresult = result;
48658   return jresult;
48659 }
48660
48661
48662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
48663   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48664   float arg2 ;
48665
48666   arg1 = (Dali::CameraActor *)jarg1;
48667   arg2 = (float)jarg2;
48668   {
48669     try {
48670       (arg1)->SetFarClippingPlane(arg2);
48671     } catch (std::out_of_range& e) {
48672       {
48673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48674       };
48675     } catch (std::exception& e) {
48676       {
48677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48678       };
48679     } catch (Dali::DaliException e) {
48680       {
48681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48682       };
48683     } catch (...) {
48684       {
48685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48686       };
48687     }
48688   }
48689
48690 }
48691
48692
48693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
48694   float jresult ;
48695   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48696   float result;
48697
48698   arg1 = (Dali::CameraActor *)jarg1;
48699   {
48700     try {
48701       result = (float)(arg1)->GetFarClippingPlane();
48702     } catch (std::out_of_range& e) {
48703       {
48704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48705       };
48706     } catch (std::exception& e) {
48707       {
48708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48709       };
48710     } catch (Dali::DaliException e) {
48711       {
48712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48713       };
48714     } catch (...) {
48715       {
48716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48717       };
48718     }
48719   }
48720
48721   jresult = result;
48722   return jresult;
48723 }
48724
48725
48726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
48727   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48728   Dali::Vector3 *arg2 = 0 ;
48729
48730   arg1 = (Dali::CameraActor *)jarg1;
48731   arg2 = (Dali::Vector3 *)jarg2;
48732   if (!arg2) {
48733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
48734     return ;
48735   }
48736   {
48737     try {
48738       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
48739     } catch (std::out_of_range& e) {
48740       {
48741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48742       };
48743     } catch (std::exception& e) {
48744       {
48745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48746       };
48747     } catch (Dali::DaliException e) {
48748       {
48749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48750       };
48751     } catch (...) {
48752       {
48753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48754       };
48755     }
48756   }
48757
48758 }
48759
48760
48761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
48762   void * jresult ;
48763   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48764   Dali::Vector3 result;
48765
48766   arg1 = (Dali::CameraActor *)jarg1;
48767   {
48768     try {
48769       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
48770     } catch (std::out_of_range& e) {
48771       {
48772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48773       };
48774     } catch (std::exception& e) {
48775       {
48776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48777       };
48778     } catch (Dali::DaliException e) {
48779       {
48780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48781       };
48782     } catch (...) {
48783       {
48784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48785       };
48786     }
48787   }
48788
48789   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
48790   return jresult;
48791 }
48792
48793
48794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
48795   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48796   bool arg2 ;
48797
48798   arg1 = (Dali::CameraActor *)jarg1;
48799   arg2 = jarg2 ? true : false;
48800   {
48801     try {
48802       (arg1)->SetInvertYAxis(arg2);
48803     } catch (std::out_of_range& e) {
48804       {
48805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48806       };
48807     } catch (std::exception& e) {
48808       {
48809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48810       };
48811     } catch (Dali::DaliException e) {
48812       {
48813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48814       };
48815     } catch (...) {
48816       {
48817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48818       };
48819     }
48820   }
48821
48822 }
48823
48824
48825 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
48826   unsigned int jresult ;
48827   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48828   bool result;
48829
48830   arg1 = (Dali::CameraActor *)jarg1;
48831   {
48832     try {
48833       result = (bool)(arg1)->GetInvertYAxis();
48834     } catch (std::out_of_range& e) {
48835       {
48836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48837       };
48838     } catch (std::exception& e) {
48839       {
48840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48841       };
48842     } catch (Dali::DaliException e) {
48843       {
48844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48845       };
48846     } catch (...) {
48847       {
48848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48849       };
48850     }
48851   }
48852
48853   jresult = result;
48854   return jresult;
48855 }
48856
48857
48858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
48859   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48860   Dali::Size *arg2 = 0 ;
48861
48862   arg1 = (Dali::CameraActor *)jarg1;
48863   arg2 = (Dali::Size *)jarg2;
48864   if (!arg2) {
48865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48866     return ;
48867   }
48868   {
48869     try {
48870       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
48871     } catch (std::out_of_range& e) {
48872       {
48873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48874       };
48875     } catch (std::exception& e) {
48876       {
48877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48878       };
48879     } catch (Dali::DaliException e) {
48880       {
48881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48882       };
48883     } catch (...) {
48884       {
48885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48886       };
48887     }
48888   }
48889
48890 }
48891
48892
48893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
48894   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48895   Dali::Size *arg2 = 0 ;
48896
48897   arg1 = (Dali::CameraActor *)jarg1;
48898   arg2 = (Dali::Size *)jarg2;
48899   if (!arg2) {
48900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
48901     return ;
48902   }
48903   {
48904     try {
48905       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
48906     } catch (std::out_of_range& e) {
48907       {
48908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48909       };
48910     } catch (std::exception& e) {
48911       {
48912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48913       };
48914     } catch (Dali::DaliException e) {
48915       {
48916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48917       };
48918     } catch (...) {
48919       {
48920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48921       };
48922     }
48923   }
48924
48925 }
48926
48927
48928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
48929   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
48930   float arg2 ;
48931   float arg3 ;
48932   float arg4 ;
48933   float arg5 ;
48934   float arg6 ;
48935   float arg7 ;
48936
48937   arg1 = (Dali::CameraActor *)jarg1;
48938   arg2 = (float)jarg2;
48939   arg3 = (float)jarg3;
48940   arg4 = (float)jarg4;
48941   arg5 = (float)jarg5;
48942   arg6 = (float)jarg6;
48943   arg7 = (float)jarg7;
48944   {
48945     try {
48946       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
48947     } catch (std::out_of_range& e) {
48948       {
48949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48950       };
48951     } catch (std::exception& e) {
48952       {
48953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48954       };
48955     } catch (Dali::DaliException e) {
48956       {
48957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48958       };
48959     } catch (...) {
48960       {
48961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48962       };
48963     }
48964   }
48965
48966 }
48967
48968
48969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
48970   void * jresult ;
48971   std::pair< std::string,Dali::Property::Value > *result = 0 ;
48972
48973   {
48974     try {
48975       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
48976     } catch (std::out_of_range& e) {
48977       {
48978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48979       };
48980     } catch (std::exception& e) {
48981       {
48982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48983       };
48984     } catch (Dali::DaliException e) {
48985       {
48986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48987       };
48988     } catch (...) {
48989       {
48990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48991       };
48992     }
48993   }
48994
48995   jresult = (void *)result;
48996   return jresult;
48997 }
48998
48999
49000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
49001   void * jresult ;
49002   std::string arg1 ;
49003   Dali::Property::Value arg2 ;
49004   Dali::Property::Value *argp2 ;
49005   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49006
49007   if (!jarg1) {
49008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49009     return 0;
49010   }
49011   (&arg1)->assign(jarg1);
49012   argp2 = (Dali::Property::Value *)jarg2;
49013   if (!argp2) {
49014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
49015     return 0;
49016   }
49017   arg2 = *argp2;
49018   {
49019     try {
49020       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
49021     } catch (std::out_of_range& e) {
49022       {
49023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49024       };
49025     } catch (std::exception& e) {
49026       {
49027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49028       };
49029     } catch (Dali::DaliException e) {
49030       {
49031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49032       };
49033     } catch (...) {
49034       {
49035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49036       };
49037     }
49038   }
49039
49040   jresult = (void *)result;
49041   return jresult;
49042 }
49043
49044
49045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
49046   void * jresult ;
49047   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
49048   std::pair< std::string,Dali::Property::Value > *result = 0 ;
49049
49050   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49051   if (!arg1) {
49052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
49053     return 0;
49054   }
49055   {
49056     try {
49057       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);
49058     } catch (std::out_of_range& e) {
49059       {
49060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49061       };
49062     } catch (std::exception& e) {
49063       {
49064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49065       };
49066     } catch (Dali::DaliException e) {
49067       {
49068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49069       };
49070     } catch (...) {
49071       {
49072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49073       };
49074     }
49075   }
49076
49077   jresult = (void *)result;
49078   return jresult;
49079 }
49080
49081
49082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
49083   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49084   std::string *arg2 = 0 ;
49085
49086   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49087   if (!jarg2) {
49088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
49089     return ;
49090   }
49091   std::string arg2_str(jarg2);
49092   arg2 = &arg2_str;
49093   if (arg1) (arg1)->first = *arg2;
49094
49095   //argout typemap for const std::string&
49096
49097 }
49098
49099
49100 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
49101   char * jresult ;
49102   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49103   std::string *result = 0 ;
49104
49105   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49106   result = (std::string *) & ((arg1)->first);
49107   jresult = SWIG_csharp_string_callback(result->c_str());
49108   return jresult;
49109 }
49110
49111
49112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
49113   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49114   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
49115
49116   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49117   arg2 = (Dali::Property::Value *)jarg2;
49118   if (arg1) (arg1)->second = *arg2;
49119 }
49120
49121
49122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
49123   void * jresult ;
49124   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49125   Dali::Property::Value *result = 0 ;
49126
49127   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49128   result = (Dali::Property::Value *)& ((arg1)->second);
49129   jresult = (void *)result;
49130   return jresult;
49131 }
49132
49133
49134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
49135   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
49136
49137   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
49138   {
49139     try {
49140       delete arg1;
49141     } catch (std::out_of_range& e) {
49142       {
49143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49144       };
49145     } catch (std::exception& e) {
49146       {
49147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49148       };
49149     } catch (Dali::DaliException e) {
49150       {
49151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49152       };
49153     } catch (...) {
49154       {
49155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49156       };
49157     }
49158   }
49159
49160 }
49161
49162
49163 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
49164   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49165
49166   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49167   {
49168     try {
49169       (arg1)->clear();
49170     } catch (std::out_of_range& e) {
49171       {
49172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49173       };
49174     } catch (std::exception& e) {
49175       {
49176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49177       };
49178     } catch (Dali::DaliException e) {
49179       {
49180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49181       };
49182     } catch (...) {
49183       {
49184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49185       };
49186     }
49187   }
49188
49189 }
49190
49191
49192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
49193   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49194   Dali::TouchPoint *arg2 = 0 ;
49195
49196   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49197   arg2 = (Dali::TouchPoint *)jarg2;
49198   if (!arg2) {
49199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49200     return ;
49201   }
49202   {
49203     try {
49204       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
49205     } catch (std::out_of_range& e) {
49206       {
49207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49208       };
49209     } catch (std::exception& e) {
49210       {
49211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49212       };
49213     } catch (Dali::DaliException e) {
49214       {
49215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49216       };
49217     } catch (...) {
49218       {
49219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49220       };
49221     }
49222   }
49223
49224 }
49225
49226
49227 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
49228   unsigned long jresult ;
49229   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49230   std::vector< Dali::TouchPoint >::size_type result;
49231
49232   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49233   {
49234     try {
49235       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
49236     } catch (std::out_of_range& e) {
49237       {
49238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49239       };
49240     } catch (std::exception& e) {
49241       {
49242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49243       };
49244     } catch (Dali::DaliException e) {
49245       {
49246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49247       };
49248     } catch (...) {
49249       {
49250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49251       };
49252     }
49253   }
49254
49255   jresult = (unsigned long)result;
49256   return jresult;
49257 }
49258
49259
49260 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
49261   unsigned long jresult ;
49262   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49263   std::vector< Dali::TouchPoint >::size_type result;
49264
49265   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49266   {
49267     try {
49268       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
49269     } catch (std::out_of_range& e) {
49270       {
49271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49272       };
49273     } catch (std::exception& e) {
49274       {
49275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49276       };
49277     } catch (Dali::DaliException e) {
49278       {
49279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49280       };
49281     } catch (...) {
49282       {
49283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49284       };
49285     }
49286   }
49287
49288   jresult = (unsigned long)result;
49289   return jresult;
49290 }
49291
49292
49293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
49294   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49295   std::vector< Dali::TouchPoint >::size_type arg2 ;
49296
49297   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49298   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
49299   {
49300     try {
49301       (arg1)->reserve(arg2);
49302     } catch (std::out_of_range& e) {
49303       {
49304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49305       };
49306     } catch (std::exception& e) {
49307       {
49308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49309       };
49310     } catch (Dali::DaliException e) {
49311       {
49312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49313       };
49314     } catch (...) {
49315       {
49316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49317       };
49318     }
49319   }
49320
49321 }
49322
49323
49324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
49325   void * jresult ;
49326   std::vector< Dali::TouchPoint > *result = 0 ;
49327
49328   {
49329     try {
49330       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
49331     } catch (std::out_of_range& e) {
49332       {
49333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49334       };
49335     } catch (std::exception& e) {
49336       {
49337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49338       };
49339     } catch (Dali::DaliException e) {
49340       {
49341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49342       };
49343     } catch (...) {
49344       {
49345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49346       };
49347     }
49348   }
49349
49350   jresult = (void *)result;
49351   return jresult;
49352 }
49353
49354
49355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
49356   void * jresult ;
49357   std::vector< Dali::TouchPoint > *arg1 = 0 ;
49358   std::vector< Dali::TouchPoint > *result = 0 ;
49359
49360   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49361   if (!arg1) {
49362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49363     return 0;
49364   }
49365   {
49366     try {
49367       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
49368     } catch (std::out_of_range& e) {
49369       {
49370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49371       };
49372     } catch (std::exception& e) {
49373       {
49374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49375       };
49376     } catch (Dali::DaliException e) {
49377       {
49378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49379       };
49380     } catch (...) {
49381       {
49382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49383       };
49384     }
49385   }
49386
49387   jresult = (void *)result;
49388   return jresult;
49389 }
49390
49391
49392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
49393   void * jresult ;
49394   int arg1 ;
49395   std::vector< Dali::TouchPoint > *result = 0 ;
49396
49397   arg1 = (int)jarg1;
49398   {
49399     try {
49400       try {
49401         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
49402       }
49403       catch(std::out_of_range &_e) {
49404         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49405         return 0;
49406       }
49407
49408     } catch (std::out_of_range& e) {
49409       {
49410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49411       };
49412     } catch (std::exception& e) {
49413       {
49414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49415       };
49416     } catch (Dali::DaliException e) {
49417       {
49418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49419       };
49420     } catch (...) {
49421       {
49422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49423       };
49424     }
49425   }
49426
49427   jresult = (void *)result;
49428   return jresult;
49429 }
49430
49431
49432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
49433   void * jresult ;
49434   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49435   int arg2 ;
49436   SwigValueWrapper< Dali::TouchPoint > result;
49437
49438   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49439   arg2 = (int)jarg2;
49440   {
49441     try {
49442       try {
49443         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
49444       }
49445       catch(std::out_of_range &_e) {
49446         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49447         return 0;
49448       }
49449
49450     } catch (std::out_of_range& e) {
49451       {
49452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49453       };
49454     } catch (std::exception& e) {
49455       {
49456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49457       };
49458     } catch (Dali::DaliException e) {
49459       {
49460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49461       };
49462     } catch (...) {
49463       {
49464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49465       };
49466     }
49467   }
49468
49469   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
49470   return jresult;
49471 }
49472
49473
49474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
49475   void * jresult ;
49476   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49477   int arg2 ;
49478   Dali::TouchPoint *result = 0 ;
49479
49480   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49481   arg2 = (int)jarg2;
49482   {
49483     try {
49484       try {
49485         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
49486       }
49487       catch(std::out_of_range &_e) {
49488         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49489         return 0;
49490       }
49491
49492     } catch (std::out_of_range& e) {
49493       {
49494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49495       };
49496     } catch (std::exception& e) {
49497       {
49498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49499       };
49500     } catch (Dali::DaliException e) {
49501       {
49502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49503       };
49504     } catch (...) {
49505       {
49506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49507       };
49508     }
49509   }
49510
49511   jresult = (void *)result;
49512   return jresult;
49513 }
49514
49515
49516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
49517   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49518   int arg2 ;
49519   Dali::TouchPoint *arg3 = 0 ;
49520
49521   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49522   arg2 = (int)jarg2;
49523   arg3 = (Dali::TouchPoint *)jarg3;
49524   if (!arg3) {
49525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49526     return ;
49527   }
49528   {
49529     try {
49530       try {
49531         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49532       }
49533       catch(std::out_of_range &_e) {
49534         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49535         return ;
49536       }
49537
49538     } catch (std::out_of_range& e) {
49539       {
49540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49541       };
49542     } catch (std::exception& e) {
49543       {
49544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49545       };
49546     } catch (Dali::DaliException e) {
49547       {
49548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49549       };
49550     } catch (...) {
49551       {
49552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49553       };
49554     }
49555   }
49556
49557 }
49558
49559
49560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
49561   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49562   std::vector< Dali::TouchPoint > *arg2 = 0 ;
49563
49564   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49565   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
49566   if (!arg2) {
49567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49568     return ;
49569   }
49570   {
49571     try {
49572       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
49573     } catch (std::out_of_range& e) {
49574       {
49575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49576       };
49577     } catch (std::exception& e) {
49578       {
49579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49580       };
49581     } catch (Dali::DaliException e) {
49582       {
49583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49584       };
49585     } catch (...) {
49586       {
49587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49588       };
49589     }
49590   }
49591
49592 }
49593
49594
49595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
49596   void * jresult ;
49597   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49598   int arg2 ;
49599   int arg3 ;
49600   std::vector< Dali::TouchPoint > *result = 0 ;
49601
49602   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49603   arg2 = (int)jarg2;
49604   arg3 = (int)jarg3;
49605   {
49606     try {
49607       try {
49608         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
49609       }
49610       catch(std::out_of_range &_e) {
49611         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49612         return 0;
49613       }
49614       catch(std::invalid_argument &_e) {
49615         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49616         return 0;
49617       }
49618
49619     } catch (std::out_of_range& e) {
49620       {
49621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49622       };
49623     } catch (std::exception& e) {
49624       {
49625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49626       };
49627     } catch (Dali::DaliException e) {
49628       {
49629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49630       };
49631     } catch (...) {
49632       {
49633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49634       };
49635     }
49636   }
49637
49638   jresult = (void *)result;
49639   return jresult;
49640 }
49641
49642
49643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
49644   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49645   int arg2 ;
49646   Dali::TouchPoint *arg3 = 0 ;
49647
49648   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49649   arg2 = (int)jarg2;
49650   arg3 = (Dali::TouchPoint *)jarg3;
49651   if (!arg3) {
49652     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49653     return ;
49654   }
49655   {
49656     try {
49657       try {
49658         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
49659       }
49660       catch(std::out_of_range &_e) {
49661         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49662         return ;
49663       }
49664
49665     } catch (std::out_of_range& e) {
49666       {
49667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49668       };
49669     } catch (std::exception& e) {
49670       {
49671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49672       };
49673     } catch (Dali::DaliException e) {
49674       {
49675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49676       };
49677     } catch (...) {
49678       {
49679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49680       };
49681     }
49682   }
49683
49684 }
49685
49686
49687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
49688   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49689   int arg2 ;
49690   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49691
49692   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49693   arg2 = (int)jarg2;
49694   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49695   if (!arg3) {
49696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49697     return ;
49698   }
49699   {
49700     try {
49701       try {
49702         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49703       }
49704       catch(std::out_of_range &_e) {
49705         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49706         return ;
49707       }
49708
49709     } catch (std::out_of_range& e) {
49710       {
49711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49712       };
49713     } catch (std::exception& e) {
49714       {
49715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49716       };
49717     } catch (Dali::DaliException e) {
49718       {
49719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49720       };
49721     } catch (...) {
49722       {
49723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49724       };
49725     }
49726   }
49727
49728 }
49729
49730
49731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
49732   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49733   int arg2 ;
49734
49735   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49736   arg2 = (int)jarg2;
49737   {
49738     try {
49739       try {
49740         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
49741       }
49742       catch(std::out_of_range &_e) {
49743         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49744         return ;
49745       }
49746
49747     } catch (std::out_of_range& e) {
49748       {
49749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49750       };
49751     } catch (std::exception& e) {
49752       {
49753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49754       };
49755     } catch (Dali::DaliException e) {
49756       {
49757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49758       };
49759     } catch (...) {
49760       {
49761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49762       };
49763     }
49764   }
49765
49766 }
49767
49768
49769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
49770   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49771   int arg2 ;
49772   int arg3 ;
49773
49774   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49775   arg2 = (int)jarg2;
49776   arg3 = (int)jarg3;
49777   {
49778     try {
49779       try {
49780         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
49781       }
49782       catch(std::out_of_range &_e) {
49783         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49784         return ;
49785       }
49786       catch(std::invalid_argument &_e) {
49787         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49788         return ;
49789       }
49790
49791     } catch (std::out_of_range& e) {
49792       {
49793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49794       };
49795     } catch (std::exception& e) {
49796       {
49797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49798       };
49799     } catch (Dali::DaliException e) {
49800       {
49801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49802       };
49803     } catch (...) {
49804       {
49805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49806       };
49807     }
49808   }
49809
49810 }
49811
49812
49813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
49814   void * jresult ;
49815   Dali::TouchPoint *arg1 = 0 ;
49816   int arg2 ;
49817   std::vector< Dali::TouchPoint > *result = 0 ;
49818
49819   arg1 = (Dali::TouchPoint *)jarg1;
49820   if (!arg1) {
49821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
49822     return 0;
49823   }
49824   arg2 = (int)jarg2;
49825   {
49826     try {
49827       try {
49828         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
49829       }
49830       catch(std::out_of_range &_e) {
49831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49832         return 0;
49833       }
49834
49835     } catch (std::out_of_range& e) {
49836       {
49837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49838       };
49839     } catch (std::exception& e) {
49840       {
49841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49842       };
49843     } catch (Dali::DaliException e) {
49844       {
49845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49846       };
49847     } catch (...) {
49848       {
49849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49850       };
49851     }
49852   }
49853
49854   jresult = (void *)result;
49855   return jresult;
49856 }
49857
49858
49859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
49860   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49861
49862   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49863   {
49864     try {
49865       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
49866     } catch (std::out_of_range& e) {
49867       {
49868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49869       };
49870     } catch (std::exception& e) {
49871       {
49872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49873       };
49874     } catch (Dali::DaliException e) {
49875       {
49876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49877       };
49878     } catch (...) {
49879       {
49880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49881       };
49882     }
49883   }
49884
49885 }
49886
49887
49888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
49889   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49890   int arg2 ;
49891   int arg3 ;
49892
49893   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49894   arg2 = (int)jarg2;
49895   arg3 = (int)jarg3;
49896   {
49897     try {
49898       try {
49899         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
49900       }
49901       catch(std::out_of_range &_e) {
49902         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49903         return ;
49904       }
49905       catch(std::invalid_argument &_e) {
49906         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
49907         return ;
49908       }
49909
49910     } catch (std::out_of_range& e) {
49911       {
49912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49913       };
49914     } catch (std::exception& e) {
49915       {
49916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49917       };
49918     } catch (Dali::DaliException e) {
49919       {
49920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49921       };
49922     } catch (...) {
49923       {
49924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49925       };
49926     }
49927   }
49928
49929 }
49930
49931
49932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
49933   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49934   int arg2 ;
49935   std::vector< Dali::TouchPoint > *arg3 = 0 ;
49936
49937   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49938   arg2 = (int)jarg2;
49939   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
49940   if (!arg3) {
49941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
49942     return ;
49943   }
49944   {
49945     try {
49946       try {
49947         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
49948       }
49949       catch(std::out_of_range &_e) {
49950         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
49951         return ;
49952       }
49953
49954     } catch (std::out_of_range& e) {
49955       {
49956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49957       };
49958     } catch (std::exception& e) {
49959       {
49960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49961       };
49962     } catch (Dali::DaliException e) {
49963       {
49964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49965       };
49966     } catch (...) {
49967       {
49968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49969       };
49970     }
49971   }
49972
49973 }
49974
49975
49976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
49977   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
49978
49979   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
49980   {
49981     try {
49982       delete arg1;
49983     } catch (std::out_of_range& e) {
49984       {
49985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49986       };
49987     } catch (std::exception& e) {
49988       {
49989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49990       };
49991     } catch (Dali::DaliException e) {
49992       {
49993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49994       };
49995     } catch (...) {
49996       {
49997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49998       };
49999     }
50000   }
50001
50002 }
50003
50004
50005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
50006   void * jresult ;
50007   Dali::Rect< int > *result = 0 ;
50008
50009   {
50010     try {
50011       result = (Dali::Rect< int > *)new Dali::Rect< int >();
50012     } catch (std::out_of_range& e) {
50013       {
50014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50015       };
50016     } catch (std::exception& e) {
50017       {
50018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50019       };
50020     } catch (Dali::DaliException e) {
50021       {
50022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50023       };
50024     } catch (...) {
50025       {
50026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50027       };
50028     }
50029   }
50030
50031   jresult = (void *)result;
50032   return jresult;
50033 }
50034
50035
50036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
50037   void * jresult ;
50038   int arg1 ;
50039   int arg2 ;
50040   int arg3 ;
50041   int arg4 ;
50042   Dali::Rect< int > *result = 0 ;
50043
50044   arg1 = (int)jarg1;
50045   arg2 = (int)jarg2;
50046   arg3 = (int)jarg3;
50047   arg4 = (int)jarg4;
50048   {
50049     try {
50050       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
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_2(void * jarg1) {
50076   void * jresult ;
50077   Dali::Rect< int > *arg1 = 0 ;
50078   Dali::Rect< int > *result = 0 ;
50079
50080   arg1 = (Dali::Rect< int > *)jarg1;
50081   if (!arg1) {
50082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50083     return 0;
50084   }
50085   {
50086     try {
50087       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
50088     } catch (std::out_of_range& e) {
50089       {
50090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50091       };
50092     } catch (std::exception& e) {
50093       {
50094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50095       };
50096     } catch (Dali::DaliException e) {
50097       {
50098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50099       };
50100     } catch (...) {
50101       {
50102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50103       };
50104     }
50105   }
50106
50107   jresult = (void *)result;
50108   return jresult;
50109 }
50110
50111
50112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
50113   void * jresult ;
50114   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50115   Dali::Rect< int > *arg2 = 0 ;
50116   Dali::Rect< int > *result = 0 ;
50117
50118   arg1 = (Dali::Rect< int > *)jarg1;
50119   arg2 = (Dali::Rect< int > *)jarg2;
50120   if (!arg2) {
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 > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
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_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
50152   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50153   int arg2 ;
50154   int arg3 ;
50155   int arg4 ;
50156   int arg5 ;
50157
50158   arg1 = (Dali::Rect< int > *)jarg1;
50159   arg2 = (int)jarg2;
50160   arg3 = (int)jarg3;
50161   arg4 = (int)jarg4;
50162   arg5 = (int)jarg5;
50163   {
50164     try {
50165       (arg1)->Set(arg2,arg3,arg4,arg5);
50166     } catch (std::out_of_range& e) {
50167       {
50168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50169       };
50170     } catch (std::exception& e) {
50171       {
50172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50173       };
50174     } catch (Dali::DaliException e) {
50175       {
50176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50177       };
50178     } catch (...) {
50179       {
50180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50181       };
50182     }
50183   }
50184
50185 }
50186
50187
50188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
50189   unsigned int jresult ;
50190   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50191   bool result;
50192
50193   arg1 = (Dali::Rect< int > *)jarg1;
50194   {
50195     try {
50196       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
50197     } catch (std::out_of_range& e) {
50198       {
50199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50200       };
50201     } catch (std::exception& e) {
50202       {
50203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50204       };
50205     } catch (Dali::DaliException e) {
50206       {
50207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50208       };
50209     } catch (...) {
50210       {
50211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50212       };
50213     }
50214   }
50215
50216   jresult = result;
50217   return jresult;
50218 }
50219
50220
50221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
50222   int jresult ;
50223   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50224   int result;
50225
50226   arg1 = (Dali::Rect< int > *)jarg1;
50227   {
50228     try {
50229       result = (int)((Dali::Rect< int > const *)arg1)->Left();
50230     } catch (std::out_of_range& e) {
50231       {
50232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50233       };
50234     } catch (std::exception& e) {
50235       {
50236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50237       };
50238     } catch (Dali::DaliException e) {
50239       {
50240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50241       };
50242     } catch (...) {
50243       {
50244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50245       };
50246     }
50247   }
50248
50249   jresult = result;
50250   return jresult;
50251 }
50252
50253
50254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
50255   int jresult ;
50256   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50257   int result;
50258
50259   arg1 = (Dali::Rect< int > *)jarg1;
50260   {
50261     try {
50262       result = (int)((Dali::Rect< int > const *)arg1)->Right();
50263     } catch (std::out_of_range& e) {
50264       {
50265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50266       };
50267     } catch (std::exception& e) {
50268       {
50269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50270       };
50271     } catch (Dali::DaliException e) {
50272       {
50273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50274       };
50275     } catch (...) {
50276       {
50277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50278       };
50279     }
50280   }
50281
50282   jresult = result;
50283   return jresult;
50284 }
50285
50286
50287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
50288   int jresult ;
50289   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50290   int result;
50291
50292   arg1 = (Dali::Rect< int > *)jarg1;
50293   {
50294     try {
50295       result = (int)((Dali::Rect< int > const *)arg1)->Top();
50296     } catch (std::out_of_range& e) {
50297       {
50298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50299       };
50300     } catch (std::exception& e) {
50301       {
50302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50303       };
50304     } catch (Dali::DaliException e) {
50305       {
50306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50307       };
50308     } catch (...) {
50309       {
50310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50311       };
50312     }
50313   }
50314
50315   jresult = result;
50316   return jresult;
50317 }
50318
50319
50320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
50321   int jresult ;
50322   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50323   int result;
50324
50325   arg1 = (Dali::Rect< int > *)jarg1;
50326   {
50327     try {
50328       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
50329     } catch (std::out_of_range& e) {
50330       {
50331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50332       };
50333     } catch (std::exception& e) {
50334       {
50335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50336       };
50337     } catch (Dali::DaliException e) {
50338       {
50339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50340       };
50341     } catch (...) {
50342       {
50343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50344       };
50345     }
50346   }
50347
50348   jresult = result;
50349   return jresult;
50350 }
50351
50352
50353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
50354   int jresult ;
50355   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50356   int result;
50357
50358   arg1 = (Dali::Rect< int > *)jarg1;
50359   {
50360     try {
50361       result = (int)((Dali::Rect< int > const *)arg1)->Area();
50362     } catch (std::out_of_range& e) {
50363       {
50364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50365       };
50366     } catch (std::exception& e) {
50367       {
50368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50369       };
50370     } catch (Dali::DaliException e) {
50371       {
50372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50373       };
50374     } catch (...) {
50375       {
50376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50377       };
50378     }
50379   }
50380
50381   jresult = result;
50382   return jresult;
50383 }
50384
50385
50386 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
50387   unsigned int jresult ;
50388   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50389   Dali::Rect< int > *arg2 = 0 ;
50390   bool result;
50391
50392   arg1 = (Dali::Rect< int > *)jarg1;
50393   arg2 = (Dali::Rect< int > *)jarg2;
50394   if (!arg2) {
50395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
50396     return 0;
50397   }
50398   {
50399     try {
50400       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
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_Contains(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)->Contains((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 void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
50465   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50466   int arg2 ;
50467
50468   arg1 = (Dali::Rect< int > *)jarg1;
50469   arg2 = (int)jarg2;
50470   if (arg1) (arg1)->x = arg2;
50471 }
50472
50473
50474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
50475   int jresult ;
50476   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50477   int result;
50478
50479   arg1 = (Dali::Rect< int > *)jarg1;
50480   result = (int) ((arg1)->x);
50481   jresult = result;
50482   return jresult;
50483 }
50484
50485
50486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
50487   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50488   int arg2 ;
50489
50490   arg1 = (Dali::Rect< int > *)jarg1;
50491   arg2 = (int)jarg2;
50492   if (arg1) (arg1)->left = arg2;
50493 }
50494
50495
50496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
50497   int jresult ;
50498   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50499   int result;
50500
50501   arg1 = (Dali::Rect< int > *)jarg1;
50502   result = (int) ((arg1)->left);
50503   jresult = result;
50504   return jresult;
50505 }
50506
50507
50508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
50509   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50510   int arg2 ;
50511
50512   arg1 = (Dali::Rect< int > *)jarg1;
50513   arg2 = (int)jarg2;
50514   if (arg1) (arg1)->y = arg2;
50515 }
50516
50517
50518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
50519   int jresult ;
50520   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50521   int result;
50522
50523   arg1 = (Dali::Rect< int > *)jarg1;
50524   result = (int) ((arg1)->y);
50525   jresult = result;
50526   return jresult;
50527 }
50528
50529
50530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
50531   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50532   int arg2 ;
50533
50534   arg1 = (Dali::Rect< int > *)jarg1;
50535   arg2 = (int)jarg2;
50536   if (arg1) (arg1)->right = arg2;
50537 }
50538
50539
50540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
50541   int jresult ;
50542   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50543   int result;
50544
50545   arg1 = (Dali::Rect< int > *)jarg1;
50546   result = (int) ((arg1)->right);
50547   jresult = result;
50548   return jresult;
50549 }
50550
50551
50552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
50553   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50554   int arg2 ;
50555
50556   arg1 = (Dali::Rect< int > *)jarg1;
50557   arg2 = (int)jarg2;
50558   if (arg1) (arg1)->width = arg2;
50559 }
50560
50561
50562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
50563   int jresult ;
50564   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50565   int result;
50566
50567   arg1 = (Dali::Rect< int > *)jarg1;
50568   result = (int) ((arg1)->width);
50569   jresult = result;
50570   return jresult;
50571 }
50572
50573
50574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
50575   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50576   int arg2 ;
50577
50578   arg1 = (Dali::Rect< int > *)jarg1;
50579   arg2 = (int)jarg2;
50580   if (arg1) (arg1)->bottom = arg2;
50581 }
50582
50583
50584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
50585   int jresult ;
50586   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50587   int result;
50588
50589   arg1 = (Dali::Rect< int > *)jarg1;
50590   result = (int) ((arg1)->bottom);
50591   jresult = result;
50592   return jresult;
50593 }
50594
50595
50596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
50597   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50598   int arg2 ;
50599
50600   arg1 = (Dali::Rect< int > *)jarg1;
50601   arg2 = (int)jarg2;
50602   if (arg1) (arg1)->height = arg2;
50603 }
50604
50605
50606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
50607   int jresult ;
50608   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50609   int result;
50610
50611   arg1 = (Dali::Rect< int > *)jarg1;
50612   result = (int) ((arg1)->height);
50613   jresult = result;
50614   return jresult;
50615 }
50616
50617
50618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
50619   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50620   int arg2 ;
50621
50622   arg1 = (Dali::Rect< int > *)jarg1;
50623   arg2 = (int)jarg2;
50624   if (arg1) (arg1)->top = arg2;
50625 }
50626
50627
50628 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
50629   int jresult ;
50630   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50631   int result;
50632
50633   arg1 = (Dali::Rect< int > *)jarg1;
50634   result = (int) ((arg1)->top);
50635   jresult = result;
50636   return jresult;
50637 }
50638
50639
50640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
50641   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
50642
50643   arg1 = (Dali::Rect< int > *)jarg1;
50644   {
50645     try {
50646       delete arg1;
50647     } catch (std::out_of_range& e) {
50648       {
50649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50650       };
50651     } catch (std::exception& e) {
50652       {
50653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50654       };
50655     } catch (Dali::DaliException e) {
50656       {
50657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50658       };
50659     } catch (...) {
50660       {
50661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50662       };
50663     }
50664   }
50665
50666 }
50667
50668
50669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
50670   void * jresult ;
50671   Dali::Rect< float > *result = 0 ;
50672
50673   {
50674     try {
50675       result = (Dali::Rect< float > *)new Dali::Rect< float >();
50676     } catch (std::out_of_range& e) {
50677       {
50678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50679       };
50680     } catch (std::exception& e) {
50681       {
50682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50683       };
50684     } catch (Dali::DaliException e) {
50685       {
50686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50687       };
50688     } catch (...) {
50689       {
50690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50691       };
50692     }
50693   }
50694
50695   jresult = (void *)result;
50696   return jresult;
50697 }
50698
50699
50700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
50701   void * jresult ;
50702   float arg1 ;
50703   float arg2 ;
50704   float arg3 ;
50705   float arg4 ;
50706   Dali::Rect< float > *result = 0 ;
50707
50708   arg1 = (float)jarg1;
50709   arg2 = (float)jarg2;
50710   arg3 = (float)jarg4;
50711   arg4 = (float)jarg3;
50712   {
50713     try {
50714       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
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_2(void * jarg1) {
50740   void * jresult ;
50741   Dali::Rect< float > *arg1 = 0 ;
50742   Dali::Rect< float > *result = 0 ;
50743
50744   arg1 = (Dali::Rect< float > *)jarg1;
50745   if (!arg1) {
50746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
50747     return 0;
50748   }
50749   {
50750     try {
50751       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
50752     } catch (std::out_of_range& e) {
50753       {
50754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50755       };
50756     } catch (std::exception& e) {
50757       {
50758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50759       };
50760     } catch (Dali::DaliException e) {
50761       {
50762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50763       };
50764     } catch (...) {
50765       {
50766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50767       };
50768     }
50769   }
50770
50771   jresult = (void *)result;
50772   return jresult;
50773 }
50774
50775
50776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
50777   void * jresult ;
50778   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50779   Dali::Rect< float > *arg2 = 0 ;
50780   Dali::Rect< float > *result = 0 ;
50781
50782   arg1 = (Dali::Rect< float > *)jarg1;
50783   arg2 = (Dali::Rect< float > *)jarg2;
50784   if (!arg2) {
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 > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
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_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
50816   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50817   float arg2 ;
50818   float arg3 ;
50819   float arg4 ;
50820   float arg5 ;
50821
50822   arg1 = (Dali::Rect< float > *)jarg1;
50823   arg2 = (float)jarg2;
50824   arg3 = (float)jarg3;
50825   arg4 = (float)jarg5;
50826   arg5 = (float)jarg4;
50827   {
50828     try {
50829       (arg1)->Set(arg2,arg3,arg4,arg5);
50830     } catch (std::out_of_range& e) {
50831       {
50832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50833       };
50834     } catch (std::exception& e) {
50835       {
50836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50837       };
50838     } catch (Dali::DaliException e) {
50839       {
50840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50841       };
50842     } catch (...) {
50843       {
50844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50845       };
50846     }
50847   }
50848
50849 }
50850
50851
50852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
50853   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50854   float arg2 ;
50855
50856   arg1 = (Dali::Rect< float > *)jarg1;
50857   arg2 = (float)jarg2;
50858   if (arg1) (arg1)->left = arg2;
50859 }
50860
50861
50862 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
50863   float jresult ;
50864   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50865   float result;
50866
50867   arg1 = (Dali::Rect< float > *)jarg1;
50868   result = (float) ((arg1)->left);
50869   jresult = result;
50870   return jresult;
50871 }
50872
50873
50874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
50875   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50876   float arg2 ;
50877
50878   arg1 = (Dali::Rect< float > *)jarg1;
50879   arg2 = (float)jarg2;
50880   if (arg1) (arg1)->left = arg2;
50881 }
50882
50883
50884 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
50885   float jresult ;
50886   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50887   float result;
50888
50889   arg1 = (Dali::Rect< float > *)jarg1;
50890   result = (float) ((arg1)->left);
50891   jresult = result;
50892   return jresult;
50893 }
50894
50895
50896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
50897   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50898   float arg2 ;
50899
50900   arg1 = (Dali::Rect< float > *)jarg1;
50901   arg2 = (float)jarg2;
50902   if (arg1) (arg1)->right = arg2;
50903 }
50904
50905
50906 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
50907   float jresult ;
50908   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50909   float result;
50910
50911   arg1 = (Dali::Rect< float > *)jarg1;
50912   result = (float) ((arg1)->right);
50913   jresult = result;
50914   return jresult;
50915 }
50916
50917
50918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
50919   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50920   float arg2 ;
50921
50922   arg1 = (Dali::Rect< float > *)jarg1;
50923   arg2 = (float)jarg2;
50924   if (arg1) (arg1)->right = arg2;
50925 }
50926
50927
50928 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
50929   float jresult ;
50930   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50931   float result;
50932
50933   arg1 = (Dali::Rect< float > *)jarg1;
50934   result = (float) ((arg1)->right);
50935   jresult = result;
50936   return jresult;
50937 }
50938
50939
50940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
50941   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50942   float arg2 ;
50943
50944   arg1 = (Dali::Rect< float > *)jarg1;
50945   arg2 = (float)jarg2;
50946   if (arg1) (arg1)->bottom = arg2;
50947 }
50948
50949
50950 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
50951   float jresult ;
50952   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50953   float result;
50954
50955   arg1 = (Dali::Rect< float > *)jarg1;
50956   result = (float) ((arg1)->bottom);
50957   jresult = result;
50958   return jresult;
50959 }
50960
50961
50962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
50963   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50964   float arg2 ;
50965
50966   arg1 = (Dali::Rect< float > *)jarg1;
50967   arg2 = (float)jarg2;
50968   if (arg1) (arg1)->top = arg2;
50969 }
50970
50971
50972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
50973   float jresult ;
50974   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50975   float result;
50976
50977   arg1 = (Dali::Rect< float > *)jarg1;
50978   result = (float) ((arg1)->top);
50979   jresult = result;
50980   return jresult;
50981 }
50982
50983
50984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
50985   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
50986
50987   arg1 = (Dali::Rect< float > *)jarg1;
50988   {
50989     try {
50990       delete arg1;
50991     } catch (std::out_of_range& e) {
50992       {
50993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50994       };
50995     } catch (std::exception& e) {
50996       {
50997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50998       };
50999     } catch (Dali::DaliException e) {
51000       {
51001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51002       };
51003     } catch (...) {
51004       {
51005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51006       };
51007     }
51008   }
51009
51010 }
51011
51012
51013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
51014   int jresult ;
51015   int result;
51016
51017   result = (int)Dali::Vector< int >::BaseType;
51018   jresult = (int)result;
51019   return jresult;
51020 }
51021
51022
51023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
51024   void * jresult ;
51025   Dali::Vector< int > *result = 0 ;
51026
51027   {
51028     try {
51029       result = (Dali::Vector< int > *)new Dali::Vector< int >();
51030     } catch (std::out_of_range& e) {
51031       {
51032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51033       };
51034     } catch (std::exception& e) {
51035       {
51036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51037       };
51038     } catch (Dali::DaliException e) {
51039       {
51040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51041       };
51042     } catch (...) {
51043       {
51044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51045       };
51046     }
51047   }
51048
51049   jresult = (void *)result;
51050   return jresult;
51051 }
51052
51053
51054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
51055   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51056
51057   arg1 = (Dali::Vector< int > *)jarg1;
51058   {
51059     try {
51060       delete arg1;
51061     } catch (std::out_of_range& e) {
51062       {
51063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51064       };
51065     } catch (std::exception& e) {
51066       {
51067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51068       };
51069     } catch (Dali::DaliException e) {
51070       {
51071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51072       };
51073     } catch (...) {
51074       {
51075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51076       };
51077     }
51078   }
51079
51080 }
51081
51082
51083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
51084   void * jresult ;
51085   Dali::Vector< int > *arg1 = 0 ;
51086   Dali::Vector< int > *result = 0 ;
51087
51088   arg1 = (Dali::Vector< int > *)jarg1;
51089   if (!arg1) {
51090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
51091     return 0;
51092   }
51093   {
51094     try {
51095       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
51096     } catch (std::out_of_range& e) {
51097       {
51098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51099       };
51100     } catch (std::exception& e) {
51101       {
51102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51103       };
51104     } catch (Dali::DaliException e) {
51105       {
51106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51107       };
51108     } catch (...) {
51109       {
51110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51111       };
51112     }
51113   }
51114
51115   jresult = (void *)result;
51116   return jresult;
51117 }
51118
51119
51120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
51121   void * jresult ;
51122   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51123   Dali::Vector< int > *arg2 = 0 ;
51124   Dali::Vector< int > *result = 0 ;
51125
51126   arg1 = (Dali::Vector< int > *)jarg1;
51127   arg2 = (Dali::Vector< int > *)jarg2;
51128   if (!arg2) {
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 > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
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_Begin(void * jarg1) {
51160   void * jresult ;
51161   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51162   Dali::Vector< int >::Iterator result;
51163
51164   arg1 = (Dali::Vector< int > *)jarg1;
51165   {
51166     try {
51167       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
51168     } catch (std::out_of_range& e) {
51169       {
51170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51171       };
51172     } catch (std::exception& e) {
51173       {
51174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51175       };
51176     } catch (Dali::DaliException e) {
51177       {
51178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51179       };
51180     } catch (...) {
51181       {
51182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51183       };
51184     }
51185   }
51186
51187   jresult = (void *)result;
51188   return jresult;
51189 }
51190
51191
51192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
51193   void * jresult ;
51194   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51195   Dali::Vector< int >::Iterator result;
51196
51197   arg1 = (Dali::Vector< int > *)jarg1;
51198   {
51199     try {
51200       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
51201     } catch (std::out_of_range& e) {
51202       {
51203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51204       };
51205     } catch (std::exception& e) {
51206       {
51207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51208       };
51209     } catch (Dali::DaliException e) {
51210       {
51211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51212       };
51213     } catch (...) {
51214       {
51215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51216       };
51217     }
51218   }
51219
51220   jresult = (void *)result;
51221   return jresult;
51222 }
51223
51224
51225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51226   void * jresult ;
51227   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51228   Dali::Vector< int >::SizeType arg2 ;
51229   Dali::Vector< int >::ItemType *result = 0 ;
51230
51231   arg1 = (Dali::Vector< int > *)jarg1;
51232   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51233   {
51234     try {
51235       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
51236     } catch (std::out_of_range& e) {
51237       {
51238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51239       };
51240     } catch (std::exception& e) {
51241       {
51242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51243       };
51244     } catch (Dali::DaliException e) {
51245       {
51246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51247       };
51248     } catch (...) {
51249       {
51250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51251       };
51252     }
51253   }
51254
51255   jresult = (void *)result;
51256   return jresult;
51257 }
51258
51259
51260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
51261   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51262   Dali::Vector< int >::ItemType *arg2 = 0 ;
51263   Dali::Vector< int >::ItemType temp2 ;
51264
51265   arg1 = (Dali::Vector< int > *)jarg1;
51266   temp2 = (Dali::Vector< int >::ItemType)jarg2;
51267   arg2 = &temp2;
51268   {
51269     try {
51270       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
51271     } catch (std::out_of_range& e) {
51272       {
51273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51274       };
51275     } catch (std::exception& e) {
51276       {
51277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51278       };
51279     } catch (Dali::DaliException e) {
51280       {
51281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51282       };
51283     } catch (...) {
51284       {
51285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51286       };
51287     }
51288   }
51289
51290 }
51291
51292
51293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
51294   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51295   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51296   Dali::Vector< int >::ItemType *arg3 = 0 ;
51297   Dali::Vector< int >::ItemType temp3 ;
51298
51299   arg1 = (Dali::Vector< int > *)jarg1;
51300   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51301   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51302   arg3 = &temp3;
51303   {
51304     try {
51305       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51306     } catch (std::out_of_range& e) {
51307       {
51308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51309       };
51310     } catch (std::exception& e) {
51311       {
51312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51313       };
51314     } catch (Dali::DaliException e) {
51315       {
51316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51317       };
51318     } catch (...) {
51319       {
51320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51321       };
51322     }
51323   }
51324
51325 }
51326
51327
51328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51329   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51330   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51331   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51332   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
51333
51334   arg1 = (Dali::Vector< int > *)jarg1;
51335   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51336   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51337   arg4 = (Dali::Vector< int >::Iterator)jarg4;
51338   {
51339     try {
51340       (arg1)->Insert(arg2,arg3,arg4);
51341     } catch (std::out_of_range& e) {
51342       {
51343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51344       };
51345     } catch (std::exception& e) {
51346       {
51347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51348       };
51349     } catch (Dali::DaliException e) {
51350       {
51351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51352       };
51353     } catch (...) {
51354       {
51355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51356       };
51357     }
51358   }
51359
51360 }
51361
51362
51363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
51364   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51365   Dali::Vector< int >::SizeType arg2 ;
51366
51367   arg1 = (Dali::Vector< int > *)jarg1;
51368   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51369   {
51370     try {
51371       (arg1)->Reserve(arg2);
51372     } catch (std::out_of_range& e) {
51373       {
51374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51375       };
51376     } catch (std::exception& e) {
51377       {
51378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51379       };
51380     } catch (Dali::DaliException e) {
51381       {
51382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51383       };
51384     } catch (...) {
51385       {
51386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51387       };
51388     }
51389   }
51390
51391 }
51392
51393
51394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51395   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51396   Dali::Vector< int >::SizeType arg2 ;
51397
51398   arg1 = (Dali::Vector< int > *)jarg1;
51399   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51400   {
51401     try {
51402       (arg1)->Resize(arg2);
51403     } catch (std::out_of_range& e) {
51404       {
51405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51406       };
51407     } catch (std::exception& e) {
51408       {
51409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51410       };
51411     } catch (Dali::DaliException e) {
51412       {
51413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51414       };
51415     } catch (...) {
51416       {
51417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51418       };
51419     }
51420   }
51421
51422 }
51423
51424
51425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
51426   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51427   Dali::Vector< int >::SizeType arg2 ;
51428   Dali::Vector< int >::ItemType *arg3 = 0 ;
51429   Dali::Vector< int >::ItemType temp3 ;
51430
51431   arg1 = (Dali::Vector< int > *)jarg1;
51432   arg2 = (Dali::Vector< int >::SizeType)jarg2;
51433   temp3 = (Dali::Vector< int >::ItemType)jarg3;
51434   arg3 = &temp3;
51435   {
51436     try {
51437       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
51438     } catch (std::out_of_range& e) {
51439       {
51440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51441       };
51442     } catch (std::exception& e) {
51443       {
51444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51445       };
51446     } catch (Dali::DaliException e) {
51447       {
51448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51449       };
51450     } catch (...) {
51451       {
51452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51453       };
51454     }
51455   }
51456
51457 }
51458
51459
51460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
51461   void * jresult ;
51462   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51463   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51464   Dali::Vector< int >::Iterator result;
51465
51466   arg1 = (Dali::Vector< int > *)jarg1;
51467   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51468   {
51469     try {
51470       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
51471     } catch (std::out_of_range& e) {
51472       {
51473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51474       };
51475     } catch (std::exception& e) {
51476       {
51477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51478       };
51479     } catch (Dali::DaliException e) {
51480       {
51481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51482       };
51483     } catch (...) {
51484       {
51485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51486       };
51487     }
51488   }
51489
51490   jresult = (void *)result;
51491   return jresult;
51492 }
51493
51494
51495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
51496   void * jresult ;
51497   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51498   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51499   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
51500   Dali::Vector< int >::Iterator result;
51501
51502   arg1 = (Dali::Vector< int > *)jarg1;
51503   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51504   arg3 = (Dali::Vector< int >::Iterator)jarg3;
51505   {
51506     try {
51507       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
51508     } catch (std::out_of_range& e) {
51509       {
51510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51511       };
51512     } catch (std::exception& e) {
51513       {
51514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51515       };
51516     } catch (Dali::DaliException e) {
51517       {
51518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51519       };
51520     } catch (...) {
51521       {
51522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51523       };
51524     }
51525   }
51526
51527   jresult = (void *)result;
51528   return jresult;
51529 }
51530
51531
51532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
51533   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51534   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
51535
51536   arg1 = (Dali::Vector< int > *)jarg1;
51537   arg2 = (Dali::Vector< int >::Iterator)jarg2;
51538   {
51539     try {
51540       (arg1)->Remove(arg2);
51541     } catch (std::out_of_range& e) {
51542       {
51543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51544       };
51545     } catch (std::exception& e) {
51546       {
51547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51548       };
51549     } catch (Dali::DaliException e) {
51550       {
51551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51552       };
51553     } catch (...) {
51554       {
51555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51556       };
51557     }
51558   }
51559
51560 }
51561
51562
51563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
51564   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51565   Dali::Vector< int > *arg2 = 0 ;
51566
51567   arg1 = (Dali::Vector< int > *)jarg1;
51568   arg2 = (Dali::Vector< int > *)jarg2;
51569   if (!arg2) {
51570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
51571     return ;
51572   }
51573   {
51574     try {
51575       (arg1)->Swap(*arg2);
51576     } catch (std::out_of_range& e) {
51577       {
51578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51579       };
51580     } catch (std::exception& e) {
51581       {
51582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51583       };
51584     } catch (Dali::DaliException e) {
51585       {
51586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51587       };
51588     } catch (...) {
51589       {
51590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51591       };
51592     }
51593   }
51594
51595 }
51596
51597
51598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
51599   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51600
51601   arg1 = (Dali::Vector< int > *)jarg1;
51602   {
51603     try {
51604       (arg1)->Clear();
51605     } catch (std::out_of_range& e) {
51606       {
51607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51608       };
51609     } catch (std::exception& e) {
51610       {
51611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51612       };
51613     } catch (Dali::DaliException e) {
51614       {
51615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51616       };
51617     } catch (...) {
51618       {
51619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51620       };
51621     }
51622   }
51623
51624 }
51625
51626
51627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
51628   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
51629
51630   arg1 = (Dali::Vector< int > *)jarg1;
51631   {
51632     try {
51633       (arg1)->Release();
51634     } catch (std::out_of_range& e) {
51635       {
51636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51637       };
51638     } catch (std::exception& e) {
51639       {
51640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51641       };
51642     } catch (Dali::DaliException e) {
51643       {
51644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51645       };
51646     } catch (...) {
51647       {
51648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51649       };
51650     }
51651   }
51652
51653 }
51654
51655
51656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
51657   int jresult ;
51658   int result;
51659
51660   result = (int)Dali::Vector< float >::BaseType;
51661   jresult = (int)result;
51662   return jresult;
51663 }
51664
51665
51666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
51667   void * jresult ;
51668   Dali::Vector< float > *result = 0 ;
51669
51670   {
51671     try {
51672       result = (Dali::Vector< float > *)new Dali::Vector< float >();
51673     } catch (std::out_of_range& e) {
51674       {
51675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51676       };
51677     } catch (std::exception& e) {
51678       {
51679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51680       };
51681     } catch (Dali::DaliException e) {
51682       {
51683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51684       };
51685     } catch (...) {
51686       {
51687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51688       };
51689     }
51690   }
51691
51692   jresult = (void *)result;
51693   return jresult;
51694 }
51695
51696
51697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
51698   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51699
51700   arg1 = (Dali::Vector< float > *)jarg1;
51701   {
51702     try {
51703       delete arg1;
51704     } catch (std::out_of_range& e) {
51705       {
51706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51707       };
51708     } catch (std::exception& e) {
51709       {
51710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51711       };
51712     } catch (Dali::DaliException e) {
51713       {
51714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51715       };
51716     } catch (...) {
51717       {
51718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51719       };
51720     }
51721   }
51722
51723 }
51724
51725
51726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
51727   void * jresult ;
51728   Dali::Vector< float > *arg1 = 0 ;
51729   Dali::Vector< float > *result = 0 ;
51730
51731   arg1 = (Dali::Vector< float > *)jarg1;
51732   if (!arg1) {
51733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
51734     return 0;
51735   }
51736   {
51737     try {
51738       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
51739     } catch (std::out_of_range& e) {
51740       {
51741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51742       };
51743     } catch (std::exception& e) {
51744       {
51745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51746       };
51747     } catch (Dali::DaliException e) {
51748       {
51749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51750       };
51751     } catch (...) {
51752       {
51753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51754       };
51755     }
51756   }
51757
51758   jresult = (void *)result;
51759   return jresult;
51760 }
51761
51762
51763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
51764   void * jresult ;
51765   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51766   Dali::Vector< float > *arg2 = 0 ;
51767   Dali::Vector< float > *result = 0 ;
51768
51769   arg1 = (Dali::Vector< float > *)jarg1;
51770   arg2 = (Dali::Vector< float > *)jarg2;
51771   if (!arg2) {
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 > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
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_Begin(void * jarg1) {
51803   void * jresult ;
51804   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51805   Dali::Vector< float >::Iterator result;
51806
51807   arg1 = (Dali::Vector< float > *)jarg1;
51808   {
51809     try {
51810       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
51811     } catch (std::out_of_range& e) {
51812       {
51813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51814       };
51815     } catch (std::exception& e) {
51816       {
51817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51818       };
51819     } catch (Dali::DaliException e) {
51820       {
51821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51822       };
51823     } catch (...) {
51824       {
51825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51826       };
51827     }
51828   }
51829
51830   jresult = (void *)result;
51831   return jresult;
51832 }
51833
51834
51835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
51836   void * jresult ;
51837   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51838   Dali::Vector< float >::Iterator result;
51839
51840   arg1 = (Dali::Vector< float > *)jarg1;
51841   {
51842     try {
51843       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
51844     } catch (std::out_of_range& e) {
51845       {
51846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51847       };
51848     } catch (std::exception& e) {
51849       {
51850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51851       };
51852     } catch (Dali::DaliException e) {
51853       {
51854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51855       };
51856     } catch (...) {
51857       {
51858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51859       };
51860     }
51861   }
51862
51863   jresult = (void *)result;
51864   return jresult;
51865 }
51866
51867
51868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51869   void * jresult ;
51870   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51871   Dali::Vector< float >::SizeType arg2 ;
51872   Dali::Vector< float >::ItemType *result = 0 ;
51873
51874   arg1 = (Dali::Vector< float > *)jarg1;
51875   arg2 = (Dali::Vector< float >::SizeType)jarg2;
51876   {
51877     try {
51878       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
51879     } catch (std::out_of_range& e) {
51880       {
51881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51882       };
51883     } catch (std::exception& e) {
51884       {
51885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51886       };
51887     } catch (Dali::DaliException e) {
51888       {
51889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51890       };
51891     } catch (...) {
51892       {
51893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51894       };
51895     }
51896   }
51897
51898   jresult = (void *)result;
51899   return jresult;
51900 }
51901
51902
51903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
51904   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51905   Dali::Vector< float >::ItemType *arg2 = 0 ;
51906   Dali::Vector< float >::ItemType temp2 ;
51907
51908   arg1 = (Dali::Vector< float > *)jarg1;
51909   temp2 = (Dali::Vector< float >::ItemType)jarg2;
51910   arg2 = &temp2;
51911   {
51912     try {
51913       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
51914     } catch (std::out_of_range& e) {
51915       {
51916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51917       };
51918     } catch (std::exception& e) {
51919       {
51920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51921       };
51922     } catch (Dali::DaliException e) {
51923       {
51924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51925       };
51926     } catch (...) {
51927       {
51928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51929       };
51930     }
51931   }
51932
51933 }
51934
51935
51936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
51937   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51938   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51939   Dali::Vector< float >::ItemType *arg3 = 0 ;
51940   Dali::Vector< float >::ItemType temp3 ;
51941
51942   arg1 = (Dali::Vector< float > *)jarg1;
51943   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51944   temp3 = (Dali::Vector< float >::ItemType)jarg3;
51945   arg3 = &temp3;
51946   {
51947     try {
51948       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
51949     } catch (std::out_of_range& e) {
51950       {
51951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51952       };
51953     } catch (std::exception& e) {
51954       {
51955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51956       };
51957     } catch (Dali::DaliException e) {
51958       {
51959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51960       };
51961     } catch (...) {
51962       {
51963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51964       };
51965     }
51966   }
51967
51968 }
51969
51970
51971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
51972   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51973   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
51974   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
51975   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
51976
51977   arg1 = (Dali::Vector< float > *)jarg1;
51978   arg2 = (Dali::Vector< float >::Iterator)jarg2;
51979   arg3 = (Dali::Vector< float >::Iterator)jarg3;
51980   arg4 = (Dali::Vector< float >::Iterator)jarg4;
51981   {
51982     try {
51983       (arg1)->Insert(arg2,arg3,arg4);
51984     } catch (std::out_of_range& e) {
51985       {
51986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51987       };
51988     } catch (std::exception& e) {
51989       {
51990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51991       };
51992     } catch (Dali::DaliException e) {
51993       {
51994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51995       };
51996     } catch (...) {
51997       {
51998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51999       };
52000     }
52001   }
52002
52003 }
52004
52005
52006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
52007   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52008   Dali::Vector< float >::SizeType arg2 ;
52009
52010   arg1 = (Dali::Vector< float > *)jarg1;
52011   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52012   {
52013     try {
52014       (arg1)->Reserve(arg2);
52015     } catch (std::out_of_range& e) {
52016       {
52017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52018       };
52019     } catch (std::exception& e) {
52020       {
52021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52022       };
52023     } catch (Dali::DaliException e) {
52024       {
52025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52026       };
52027     } catch (...) {
52028       {
52029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52030       };
52031     }
52032   }
52033
52034 }
52035
52036 //// ========================= end of part 2 =============================
52037
52038 //// ========================== start part 3 ===============================
52039
52040
52041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52042   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52043   Dali::Vector< float >::SizeType arg2 ;
52044
52045   arg1 = (Dali::Vector< float > *)jarg1;
52046   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52047   {
52048     try {
52049       (arg1)->Resize(arg2);
52050     } catch (std::out_of_range& e) {
52051       {
52052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52053       };
52054     } catch (std::exception& e) {
52055       {
52056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52057       };
52058     } catch (Dali::DaliException e) {
52059       {
52060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52061       };
52062     } catch (...) {
52063       {
52064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52065       };
52066     }
52067   }
52068
52069 }
52070
52071
52072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
52073   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52074   Dali::Vector< float >::SizeType arg2 ;
52075   Dali::Vector< float >::ItemType *arg3 = 0 ;
52076   Dali::Vector< float >::ItemType temp3 ;
52077
52078   arg1 = (Dali::Vector< float > *)jarg1;
52079   arg2 = (Dali::Vector< float >::SizeType)jarg2;
52080   temp3 = (Dali::Vector< float >::ItemType)jarg3;
52081   arg3 = &temp3;
52082   {
52083     try {
52084       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
52085     } catch (std::out_of_range& e) {
52086       {
52087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52088       };
52089     } catch (std::exception& e) {
52090       {
52091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52092       };
52093     } catch (Dali::DaliException e) {
52094       {
52095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52096       };
52097     } catch (...) {
52098       {
52099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52100       };
52101     }
52102   }
52103
52104 }
52105
52106
52107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
52108   void * jresult ;
52109   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52110   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52111   Dali::Vector< float >::Iterator result;
52112
52113   arg1 = (Dali::Vector< float > *)jarg1;
52114   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52115   {
52116     try {
52117       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
52118     } catch (std::out_of_range& e) {
52119       {
52120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52121       };
52122     } catch (std::exception& e) {
52123       {
52124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52125       };
52126     } catch (Dali::DaliException e) {
52127       {
52128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52129       };
52130     } catch (...) {
52131       {
52132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52133       };
52134     }
52135   }
52136
52137   jresult = (void *)result;
52138   return jresult;
52139 }
52140
52141
52142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52143   void * jresult ;
52144   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52145   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52146   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
52147   Dali::Vector< float >::Iterator result;
52148
52149   arg1 = (Dali::Vector< float > *)jarg1;
52150   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52151   arg3 = (Dali::Vector< float >::Iterator)jarg3;
52152   {
52153     try {
52154       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
52155     } catch (std::out_of_range& e) {
52156       {
52157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52158       };
52159     } catch (std::exception& e) {
52160       {
52161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52162       };
52163     } catch (Dali::DaliException e) {
52164       {
52165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52166       };
52167     } catch (...) {
52168       {
52169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52170       };
52171     }
52172   }
52173
52174   jresult = (void *)result;
52175   return jresult;
52176 }
52177
52178
52179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
52180   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52181   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
52182
52183   arg1 = (Dali::Vector< float > *)jarg1;
52184   arg2 = (Dali::Vector< float >::Iterator)jarg2;
52185   {
52186     try {
52187       (arg1)->Remove(arg2);
52188     } catch (std::out_of_range& e) {
52189       {
52190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52191       };
52192     } catch (std::exception& e) {
52193       {
52194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52195       };
52196     } catch (Dali::DaliException e) {
52197       {
52198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52199       };
52200     } catch (...) {
52201       {
52202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52203       };
52204     }
52205   }
52206
52207 }
52208
52209
52210 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
52211   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52212   Dali::Vector< float > *arg2 = 0 ;
52213
52214   arg1 = (Dali::Vector< float > *)jarg1;
52215   arg2 = (Dali::Vector< float > *)jarg2;
52216   if (!arg2) {
52217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
52218     return ;
52219   }
52220   {
52221     try {
52222       (arg1)->Swap(*arg2);
52223     } catch (std::out_of_range& e) {
52224       {
52225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52226       };
52227     } catch (std::exception& e) {
52228       {
52229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52230       };
52231     } catch (Dali::DaliException e) {
52232       {
52233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52234       };
52235     } catch (...) {
52236       {
52237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52238       };
52239     }
52240   }
52241
52242 }
52243
52244
52245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
52246   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52247
52248   arg1 = (Dali::Vector< float > *)jarg1;
52249   {
52250     try {
52251       (arg1)->Clear();
52252     } catch (std::out_of_range& e) {
52253       {
52254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52255       };
52256     } catch (std::exception& e) {
52257       {
52258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52259       };
52260     } catch (Dali::DaliException e) {
52261       {
52262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52263       };
52264     } catch (...) {
52265       {
52266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52267       };
52268     }
52269   }
52270
52271 }
52272
52273
52274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
52275   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
52276
52277   arg1 = (Dali::Vector< float > *)jarg1;
52278   {
52279     try {
52280       (arg1)->Release();
52281     } catch (std::out_of_range& e) {
52282       {
52283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52284       };
52285     } catch (std::exception& e) {
52286       {
52287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52288       };
52289     } catch (Dali::DaliException e) {
52290       {
52291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52292       };
52293     } catch (...) {
52294       {
52295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52296       };
52297     }
52298   }
52299
52300 }
52301
52302
52303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
52304   int jresult ;
52305   int result;
52306
52307   result = (int)Dali::Vector< unsigned char >::BaseType;
52308   jresult = (int)result;
52309   return jresult;
52310 }
52311
52312
52313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
52314   void * jresult ;
52315   Dali::Vector< unsigned char > *result = 0 ;
52316
52317   {
52318     try {
52319       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
52320     } catch (std::out_of_range& e) {
52321       {
52322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52323       };
52324     } catch (std::exception& e) {
52325       {
52326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52327       };
52328     } catch (Dali::DaliException e) {
52329       {
52330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52331       };
52332     } catch (...) {
52333       {
52334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52335       };
52336     }
52337   }
52338
52339   jresult = (void *)result;
52340   return jresult;
52341 }
52342
52343
52344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
52345   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52346
52347   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52348   {
52349     try {
52350       delete arg1;
52351     } catch (std::out_of_range& e) {
52352       {
52353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52354       };
52355     } catch (std::exception& e) {
52356       {
52357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52358       };
52359     } catch (Dali::DaliException e) {
52360       {
52361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52362       };
52363     } catch (...) {
52364       {
52365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52366       };
52367     }
52368   }
52369
52370 }
52371
52372
52373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
52374   void * jresult ;
52375   Dali::Vector< unsigned char > *arg1 = 0 ;
52376   Dali::Vector< unsigned char > *result = 0 ;
52377
52378   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52379   if (!arg1) {
52380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
52381     return 0;
52382   }
52383   {
52384     try {
52385       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
52386     } catch (std::out_of_range& e) {
52387       {
52388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52389       };
52390     } catch (std::exception& e) {
52391       {
52392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52393       };
52394     } catch (Dali::DaliException e) {
52395       {
52396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52397       };
52398     } catch (...) {
52399       {
52400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52401       };
52402     }
52403   }
52404
52405   jresult = (void *)result;
52406   return jresult;
52407 }
52408
52409
52410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
52411   void * jresult ;
52412   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52413   Dali::Vector< unsigned char > *arg2 = 0 ;
52414   Dali::Vector< unsigned char > *result = 0 ;
52415
52416   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52417   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52418   if (!arg2) {
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 > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
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_Begin(void * jarg1) {
52450   void * jresult ;
52451   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52452   Dali::Vector< unsigned char >::Iterator result;
52453
52454   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52455   {
52456     try {
52457       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
52458     } catch (std::out_of_range& e) {
52459       {
52460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52461       };
52462     } catch (std::exception& e) {
52463       {
52464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52465       };
52466     } catch (Dali::DaliException e) {
52467       {
52468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52469       };
52470     } catch (...) {
52471       {
52472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52473       };
52474     }
52475   }
52476
52477   jresult = (void *)result;
52478   return jresult;
52479 }
52480
52481
52482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
52483   void * jresult ;
52484   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52485   Dali::Vector< unsigned char >::Iterator result;
52486
52487   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52488   {
52489     try {
52490       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
52491     } catch (std::out_of_range& e) {
52492       {
52493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52494       };
52495     } catch (std::exception& e) {
52496       {
52497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52498       };
52499     } catch (Dali::DaliException e) {
52500       {
52501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52502       };
52503     } catch (...) {
52504       {
52505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52506       };
52507     }
52508   }
52509
52510   jresult = (void *)result;
52511   return jresult;
52512 }
52513
52514
52515 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
52516   void * jresult ;
52517   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52518   Dali::Vector< unsigned char >::SizeType arg2 ;
52519   Dali::Vector< unsigned char >::ItemType *result = 0 ;
52520
52521   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52522   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52523   {
52524     try {
52525       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
52526     } catch (std::out_of_range& e) {
52527       {
52528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52529       };
52530     } catch (std::exception& e) {
52531       {
52532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52533       };
52534     } catch (Dali::DaliException e) {
52535       {
52536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52537       };
52538     } catch (...) {
52539       {
52540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52541       };
52542     }
52543   }
52544
52545   jresult = (void *)result;
52546   return jresult;
52547 }
52548
52549
52550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
52551   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52552   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
52553   Dali::Vector< unsigned char >::ItemType temp2 ;
52554
52555   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52556   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
52557   arg2 = &temp2;
52558   {
52559     try {
52560       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
52561     } catch (std::out_of_range& e) {
52562       {
52563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52564       };
52565     } catch (std::exception& e) {
52566       {
52567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52568       };
52569     } catch (Dali::DaliException e) {
52570       {
52571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52572       };
52573     } catch (...) {
52574       {
52575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52576       };
52577     }
52578   }
52579
52580 }
52581
52582
52583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
52584   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52585   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52586   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52587   Dali::Vector< unsigned char >::ItemType temp3 ;
52588
52589   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52590   arg2 = jarg2;
52591   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52592   arg3 = &temp3;
52593   {
52594     try {
52595       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52596     } catch (std::out_of_range& e) {
52597       {
52598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52599       };
52600     } catch (std::exception& e) {
52601       {
52602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52603       };
52604     } catch (Dali::DaliException e) {
52605       {
52606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52607       };
52608     } catch (...) {
52609       {
52610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52611       };
52612     }
52613   }
52614
52615
52616
52617 }
52618
52619
52620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
52621   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52622   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52623   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52624   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52625
52626   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52627   arg2 = jarg2;
52628   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52629   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
52630   {
52631     try {
52632       (arg1)->Insert(arg2,arg3,arg4);
52633     } catch (std::out_of_range& e) {
52634       {
52635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52636       };
52637     } catch (std::exception& e) {
52638       {
52639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52640       };
52641     } catch (Dali::DaliException e) {
52642       {
52643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52644       };
52645     } catch (...) {
52646       {
52647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52648       };
52649     }
52650   }
52651
52652
52653
52654 }
52655
52656
52657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
52658   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52659   Dali::Vector< unsigned char >::SizeType arg2 ;
52660
52661   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52662   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52663   {
52664     try {
52665       (arg1)->Reserve(arg2);
52666     } catch (std::out_of_range& e) {
52667       {
52668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52669       };
52670     } catch (std::exception& e) {
52671       {
52672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52673       };
52674     } catch (Dali::DaliException e) {
52675       {
52676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52677       };
52678     } catch (...) {
52679       {
52680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52681       };
52682     }
52683   }
52684
52685 }
52686
52687
52688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52689   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52690   Dali::Vector< unsigned char >::SizeType arg2 ;
52691
52692   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52693   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52694   {
52695     try {
52696       (arg1)->Resize(arg2);
52697     } catch (std::out_of_range& e) {
52698       {
52699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52700       };
52701     } catch (std::exception& e) {
52702       {
52703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52704       };
52705     } catch (Dali::DaliException e) {
52706       {
52707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52708       };
52709     } catch (...) {
52710       {
52711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52712       };
52713     }
52714   }
52715
52716 }
52717
52718
52719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
52720   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52721   Dali::Vector< unsigned char >::SizeType arg2 ;
52722   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
52723   Dali::Vector< unsigned char >::ItemType temp3 ;
52724
52725   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52726   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
52727   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
52728   arg3 = &temp3;
52729   {
52730     try {
52731       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
52732     } catch (std::out_of_range& e) {
52733       {
52734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52735       };
52736     } catch (std::exception& e) {
52737       {
52738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52739       };
52740     } catch (Dali::DaliException e) {
52741       {
52742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52743       };
52744     } catch (...) {
52745       {
52746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52747       };
52748     }
52749   }
52750
52751 }
52752
52753
52754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
52755   void * jresult ;
52756   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52757   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52758   Dali::Vector< unsigned char >::Iterator result;
52759
52760   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52761   arg2 = jarg2;
52762   {
52763     try {
52764       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
52765     } catch (std::out_of_range& e) {
52766       {
52767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52768       };
52769     } catch (std::exception& e) {
52770       {
52771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52772       };
52773     } catch (Dali::DaliException e) {
52774       {
52775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52776       };
52777     } catch (...) {
52778       {
52779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52780       };
52781     }
52782   }
52783
52784   jresult = (void *)result;
52785
52786
52787   return jresult;
52788 }
52789
52790
52791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
52792   void * jresult ;
52793   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52794   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52795   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52796   Dali::Vector< unsigned char >::Iterator result;
52797
52798   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52799   arg2 = jarg2;
52800   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
52801   {
52802     try {
52803       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
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_Remove(void * jarg1, unsigned char* jarg2) {
52831   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52832   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
52833
52834   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52835   arg2 = jarg2;
52836   {
52837     try {
52838       (arg1)->Remove(arg2);
52839     } catch (std::out_of_range& e) {
52840       {
52841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52842       };
52843     } catch (std::exception& e) {
52844       {
52845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52846       };
52847     } catch (Dali::DaliException e) {
52848       {
52849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52850       };
52851     } catch (...) {
52852       {
52853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52854       };
52855     }
52856   }
52857
52858
52859
52860 }
52861
52862
52863 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
52864   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52865   Dali::Vector< unsigned char > *arg2 = 0 ;
52866
52867   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52868   arg2 = (Dali::Vector< unsigned char > *)jarg2;
52869   if (!arg2) {
52870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
52871     return ;
52872   }
52873   {
52874     try {
52875       (arg1)->Swap(*arg2);
52876     } catch (std::out_of_range& e) {
52877       {
52878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52879       };
52880     } catch (std::exception& e) {
52881       {
52882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52883       };
52884     } catch (Dali::DaliException e) {
52885       {
52886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52887       };
52888     } catch (...) {
52889       {
52890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52891       };
52892     }
52893   }
52894
52895 }
52896
52897
52898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
52899   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52900
52901   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52902   {
52903     try {
52904       (arg1)->Clear();
52905     } catch (std::out_of_range& e) {
52906       {
52907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52908       };
52909     } catch (std::exception& e) {
52910       {
52911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52912       };
52913     } catch (Dali::DaliException e) {
52914       {
52915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52916       };
52917     } catch (...) {
52918       {
52919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52920       };
52921     }
52922   }
52923
52924 }
52925
52926
52927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
52928   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
52929
52930   arg1 = (Dali::Vector< unsigned char > *)jarg1;
52931   {
52932     try {
52933       (arg1)->Release();
52934     } catch (std::out_of_range& e) {
52935       {
52936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52937       };
52938     } catch (std::exception& e) {
52939       {
52940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52941       };
52942     } catch (Dali::DaliException e) {
52943       {
52944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52945       };
52946     } catch (...) {
52947       {
52948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52949       };
52950     }
52951   }
52952
52953 }
52954
52955
52956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
52957   int jresult ;
52958   int result;
52959
52960   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
52961   jresult = (int)result;
52962   return jresult;
52963 }
52964
52965
52966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
52967   void * jresult ;
52968   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
52969
52970   {
52971     try {
52972       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
52973     } catch (std::out_of_range& e) {
52974       {
52975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52976       };
52977     } catch (std::exception& e) {
52978       {
52979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52980       };
52981     } catch (Dali::DaliException e) {
52982       {
52983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52984       };
52985     } catch (...) {
52986       {
52987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52988       };
52989     }
52990   }
52991
52992   jresult = (void *)result;
52993   return jresult;
52994 }
52995
52996
52997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
52998   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52999
53000   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53001   {
53002     try {
53003       delete arg1;
53004     } catch (std::out_of_range& e) {
53005       {
53006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53007       };
53008     } catch (std::exception& e) {
53009       {
53010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53011       };
53012     } catch (Dali::DaliException e) {
53013       {
53014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53015       };
53016     } catch (...) {
53017       {
53018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53019       };
53020     }
53021   }
53022
53023 }
53024
53025
53026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
53027   void * jresult ;
53028   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
53029   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53030
53031   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53032   if (!arg1) {
53033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
53034     return 0;
53035   }
53036   {
53037     try {
53038       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
53039     } catch (std::out_of_range& e) {
53040       {
53041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53042       };
53043     } catch (std::exception& e) {
53044       {
53045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53046       };
53047     } catch (Dali::DaliException e) {
53048       {
53049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53050       };
53051     } catch (...) {
53052       {
53053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53054       };
53055     }
53056   }
53057
53058   jresult = (void *)result;
53059   return jresult;
53060 }
53061
53062
53063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
53064   void * jresult ;
53065   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53066   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53067   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
53068
53069   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53070   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53071   if (!arg2) {
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 > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
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_Begin(void * jarg1) {
53103   void * jresult ;
53104   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53105   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53106
53107   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53108   {
53109     try {
53110       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
53111     } catch (std::out_of_range& e) {
53112       {
53113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53114       };
53115     } catch (std::exception& e) {
53116       {
53117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53118       };
53119     } catch (Dali::DaliException e) {
53120       {
53121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53122       };
53123     } catch (...) {
53124       {
53125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53126       };
53127     }
53128   }
53129
53130   jresult = (void *)result;
53131   return jresult;
53132 }
53133
53134
53135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
53136   void * jresult ;
53137   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53138   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53139
53140   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53141   {
53142     try {
53143       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
53144     } catch (std::out_of_range& e) {
53145       {
53146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53147       };
53148     } catch (std::exception& e) {
53149       {
53150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53151       };
53152     } catch (Dali::DaliException e) {
53153       {
53154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53155       };
53156     } catch (...) {
53157       {
53158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53159       };
53160     }
53161   }
53162
53163   jresult = (void *)result;
53164   return jresult;
53165 }
53166
53167
53168 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
53169   void * jresult ;
53170   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53171   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53172   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
53173
53174   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53175   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53176   {
53177     try {
53178       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
53179     } catch (std::out_of_range& e) {
53180       {
53181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53182       };
53183     } catch (std::exception& e) {
53184       {
53185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53186       };
53187     } catch (Dali::DaliException e) {
53188       {
53189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53190       };
53191     } catch (...) {
53192       {
53193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53194       };
53195     }
53196   }
53197
53198   jresult = (void *)result;
53199   return jresult;
53200 }
53201
53202
53203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
53204   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53205   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
53206
53207   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53208   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
53209   if (!arg2) {
53210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53211     return ;
53212   }
53213   {
53214     try {
53215       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
53216     } catch (std::out_of_range& e) {
53217       {
53218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53219       };
53220     } catch (std::exception& e) {
53221       {
53222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53223       };
53224     } catch (Dali::DaliException e) {
53225       {
53226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53227       };
53228     } catch (...) {
53229       {
53230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53231       };
53232     }
53233   }
53234
53235 }
53236
53237
53238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
53239   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53240   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53241   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53242
53243   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53244   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53245   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53246   if (!arg3) {
53247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53248     return ;
53249   }
53250   {
53251     try {
53252       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53253     } catch (std::out_of_range& e) {
53254       {
53255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53256       };
53257     } catch (std::exception& e) {
53258       {
53259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53260       };
53261     } catch (Dali::DaliException e) {
53262       {
53263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53264       };
53265     } catch (...) {
53266       {
53267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53268       };
53269     }
53270   }
53271
53272 }
53273
53274
53275 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
53276   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53277   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53278   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53279   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53280
53281   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53282   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53283   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53284   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
53285   {
53286     try {
53287       (arg1)->Insert(arg2,arg3,arg4);
53288     } catch (std::out_of_range& e) {
53289       {
53290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53291       };
53292     } catch (std::exception& e) {
53293       {
53294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53295       };
53296     } catch (Dali::DaliException e) {
53297       {
53298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53299       };
53300     } catch (...) {
53301       {
53302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53303       };
53304     }
53305   }
53306
53307 }
53308
53309
53310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
53311   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53312   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53313
53314   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53315   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53316   {
53317     try {
53318       (arg1)->Reserve(arg2);
53319     } catch (std::out_of_range& e) {
53320       {
53321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53322       };
53323     } catch (std::exception& e) {
53324       {
53325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53326       };
53327     } catch (Dali::DaliException e) {
53328       {
53329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53330       };
53331     } catch (...) {
53332       {
53333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53334       };
53335     }
53336   }
53337
53338 }
53339
53340
53341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
53342   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53343   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53344
53345   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53346   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53347   {
53348     try {
53349       (arg1)->Resize(arg2);
53350     } catch (std::out_of_range& e) {
53351       {
53352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53353       };
53354     } catch (std::exception& e) {
53355       {
53356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53357       };
53358     } catch (Dali::DaliException e) {
53359       {
53360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53361       };
53362     } catch (...) {
53363       {
53364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53365       };
53366     }
53367   }
53368
53369 }
53370
53371
53372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
53373   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53374   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
53375   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
53376
53377   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53378   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
53379   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
53380   if (!arg3) {
53381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
53382     return ;
53383   }
53384   {
53385     try {
53386       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
53387     } catch (std::out_of_range& e) {
53388       {
53389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53390       };
53391     } catch (std::exception& e) {
53392       {
53393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53394       };
53395     } catch (Dali::DaliException e) {
53396       {
53397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53398       };
53399     } catch (...) {
53400       {
53401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53402       };
53403     }
53404   }
53405
53406 }
53407
53408
53409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
53410   void * jresult ;
53411   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53412   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53413   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53414
53415   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53416   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53417   {
53418     try {
53419       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
53420     } catch (std::out_of_range& e) {
53421       {
53422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53423       };
53424     } catch (std::exception& e) {
53425       {
53426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53427       };
53428     } catch (Dali::DaliException e) {
53429       {
53430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53431       };
53432     } catch (...) {
53433       {
53434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53435       };
53436     }
53437   }
53438
53439   jresult = (void *)result;
53440   return jresult;
53441 }
53442
53443
53444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
53445   void * jresult ;
53446   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53447   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53448   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53449   Dali::Vector< Dali::Uint16Pair >::Iterator result;
53450
53451   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53452   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53453   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
53454   {
53455     try {
53456       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
53457     } catch (std::out_of_range& e) {
53458       {
53459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53460       };
53461     } catch (std::exception& e) {
53462       {
53463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53464       };
53465     } catch (Dali::DaliException e) {
53466       {
53467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53468       };
53469     } catch (...) {
53470       {
53471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53472       };
53473     }
53474   }
53475
53476   jresult = (void *)result;
53477   return jresult;
53478 }
53479
53480
53481 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
53482   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53483   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
53484
53485   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53486   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
53487   {
53488     try {
53489       (arg1)->Remove(arg2);
53490     } catch (std::out_of_range& e) {
53491       {
53492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53493       };
53494     } catch (std::exception& e) {
53495       {
53496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53497       };
53498     } catch (Dali::DaliException e) {
53499       {
53500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53501       };
53502     } catch (...) {
53503       {
53504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53505       };
53506     }
53507   }
53508
53509 }
53510
53511
53512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
53513   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53514   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
53515
53516   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53517   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
53518   if (!arg2) {
53519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
53520     return ;
53521   }
53522   {
53523     try {
53524       (arg1)->Swap(*arg2);
53525     } catch (std::out_of_range& e) {
53526       {
53527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53528       };
53529     } catch (std::exception& e) {
53530       {
53531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53532       };
53533     } catch (Dali::DaliException e) {
53534       {
53535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53536       };
53537     } catch (...) {
53538       {
53539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53540       };
53541     }
53542   }
53543
53544 }
53545
53546
53547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
53548   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53549
53550   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53551   {
53552     try {
53553       (arg1)->Clear();
53554     } catch (std::out_of_range& e) {
53555       {
53556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53557       };
53558     } catch (std::exception& e) {
53559       {
53560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53561       };
53562     } catch (Dali::DaliException e) {
53563       {
53564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53565       };
53566     } catch (...) {
53567       {
53568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53569       };
53570     }
53571   }
53572
53573 }
53574
53575
53576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
53577   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
53578
53579   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
53580   {
53581     try {
53582       (arg1)->Release();
53583     } catch (std::out_of_range& e) {
53584       {
53585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53586       };
53587     } catch (std::exception& e) {
53588       {
53589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53590       };
53591     } catch (Dali::DaliException e) {
53592       {
53593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53594       };
53595     } catch (...) {
53596       {
53597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53598       };
53599     }
53600   }
53601
53602 }
53603
53604
53605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
53606   void * jresult ;
53607   Dali::Signal< void () > *result = 0 ;
53608
53609   {
53610     try {
53611       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
53612     } catch (std::out_of_range& e) {
53613       {
53614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53615       };
53616     } catch (std::exception& e) {
53617       {
53618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53619       };
53620     } catch (Dali::DaliException e) {
53621       {
53622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53623       };
53624     } catch (...) {
53625       {
53626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53627       };
53628     }
53629   }
53630
53631   jresult = (void *)result;
53632   return jresult;
53633 }
53634
53635
53636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
53637   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53638
53639   arg1 = (Dali::Signal< void () > *)jarg1;
53640   {
53641     try {
53642       delete arg1;
53643     } catch (std::out_of_range& e) {
53644       {
53645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53646       };
53647     } catch (std::exception& e) {
53648       {
53649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53650       };
53651     } catch (Dali::DaliException e) {
53652       {
53653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53654       };
53655     } catch (...) {
53656       {
53657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53658       };
53659     }
53660   }
53661
53662 }
53663
53664
53665 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
53666   unsigned int jresult ;
53667   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53668   bool result;
53669
53670   arg1 = (Dali::Signal< void () > *)jarg1;
53671   {
53672     try {
53673       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
53674     } catch (std::out_of_range& e) {
53675       {
53676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53677       };
53678     } catch (std::exception& e) {
53679       {
53680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53681       };
53682     } catch (Dali::DaliException e) {
53683       {
53684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53685       };
53686     } catch (...) {
53687       {
53688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53689       };
53690     }
53691   }
53692
53693   jresult = result;
53694   return jresult;
53695 }
53696
53697
53698 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
53699   unsigned long jresult ;
53700   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53701   std::size_t result;
53702
53703   arg1 = (Dali::Signal< void () > *)jarg1;
53704   {
53705     try {
53706       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
53707     } catch (std::out_of_range& e) {
53708       {
53709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53710       };
53711     } catch (std::exception& e) {
53712       {
53713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53714       };
53715     } catch (Dali::DaliException e) {
53716       {
53717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53718       };
53719     } catch (...) {
53720       {
53721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53722       };
53723     }
53724   }
53725
53726   jresult = (unsigned long)result;
53727   return jresult;
53728 }
53729
53730
53731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
53732   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53733   void (*arg2)() = (void (*)()) 0 ;
53734
53735   arg1 = (Dali::Signal< void () > *)jarg1;
53736   arg2 = (void (*)())jarg2;
53737   {
53738     try {
53739       (arg1)->Connect(arg2);
53740     } catch (std::out_of_range& e) {
53741       {
53742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53743       };
53744     } catch (std::exception& e) {
53745       {
53746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53747       };
53748     } catch (Dali::DaliException e) {
53749       {
53750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53751       };
53752     } catch (...) {
53753       {
53754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53755       };
53756     }
53757   }
53758
53759 }
53760
53761
53762 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
53763   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53764   void (*arg2)() = (void (*)()) 0 ;
53765
53766   arg1 = (Dali::Signal< void () > *)jarg1;
53767   arg2 = (void (*)())jarg2;
53768   {
53769     try {
53770       (arg1)->Disconnect(arg2);
53771     } catch (std::out_of_range& e) {
53772       {
53773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53774       };
53775     } catch (std::exception& e) {
53776       {
53777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53778       };
53779     } catch (Dali::DaliException e) {
53780       {
53781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53782       };
53783     } catch (...) {
53784       {
53785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53786       };
53787     }
53788   }
53789
53790 }
53791
53792
53793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
53794   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53795   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
53796   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
53797
53798   arg1 = (Dali::Signal< void () > *)jarg1;
53799   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
53800   arg3 = (Dali::FunctorDelegate *)jarg3;
53801   {
53802     try {
53803       (arg1)->Connect(arg2,arg3);
53804     } catch (std::out_of_range& e) {
53805       {
53806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53807       };
53808     } catch (std::exception& e) {
53809       {
53810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53811       };
53812     } catch (Dali::DaliException e) {
53813       {
53814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53815       };
53816     } catch (...) {
53817       {
53818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53819       };
53820     }
53821   }
53822
53823 }
53824
53825
53826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
53827   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
53828
53829   arg1 = (Dali::Signal< void () > *)jarg1;
53830   {
53831     try {
53832       (arg1)->Emit();
53833     } catch (std::out_of_range& e) {
53834       {
53835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53836       };
53837     } catch (std::exception& e) {
53838       {
53839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53840       };
53841     } catch (Dali::DaliException e) {
53842       {
53843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53844       };
53845     } catch (...) {
53846       {
53847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53848       };
53849     }
53850   }
53851
53852 }
53853
53854
53855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
53856   unsigned int jresult ;
53857   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53858   bool result;
53859
53860   arg1 = (Dali::Signal< void (float) > *)jarg1;
53861   {
53862     try {
53863       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
53864     } catch (std::out_of_range& e) {
53865       {
53866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53867       };
53868     } catch (std::exception& e) {
53869       {
53870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53871       };
53872     } catch (Dali::DaliException e) {
53873       {
53874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53875       };
53876     } catch (...) {
53877       {
53878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53879       };
53880     }
53881   }
53882
53883   jresult = result;
53884   return jresult;
53885 }
53886
53887
53888 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
53889   unsigned long jresult ;
53890   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53891   std::size_t result;
53892
53893   arg1 = (Dali::Signal< void (float) > *)jarg1;
53894   {
53895     try {
53896       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
53897     } catch (std::out_of_range& e) {
53898       {
53899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53900       };
53901     } catch (std::exception& e) {
53902       {
53903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53904       };
53905     } catch (Dali::DaliException e) {
53906       {
53907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53908       };
53909     } catch (...) {
53910       {
53911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53912       };
53913     }
53914   }
53915
53916   jresult = (unsigned long)result;
53917   return jresult;
53918 }
53919
53920
53921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
53922   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53923   void (*arg2)(float) = (void (*)(float)) 0 ;
53924
53925   arg1 = (Dali::Signal< void (float) > *)jarg1;
53926   arg2 = (void (*)(float))jarg2;
53927   {
53928     try {
53929       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
53930     } catch (std::out_of_range& e) {
53931       {
53932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53933       };
53934     } catch (std::exception& e) {
53935       {
53936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53937       };
53938     } catch (Dali::DaliException e) {
53939       {
53940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53941       };
53942     } catch (...) {
53943       {
53944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53945       };
53946     }
53947   }
53948
53949 }
53950
53951
53952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
53953   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53954   void (*arg2)(float) = (void (*)(float)) 0 ;
53955
53956   arg1 = (Dali::Signal< void (float) > *)jarg1;
53957   arg2 = (void (*)(float))jarg2;
53958   {
53959     try {
53960       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
53961     } catch (std::out_of_range& e) {
53962       {
53963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53964       };
53965     } catch (std::exception& e) {
53966       {
53967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53968       };
53969     } catch (Dali::DaliException e) {
53970       {
53971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53972       };
53973     } catch (...) {
53974       {
53975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53976       };
53977     }
53978   }
53979
53980 }
53981
53982
53983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
53984   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
53985   float arg2 ;
53986
53987   arg1 = (Dali::Signal< void (float) > *)jarg1;
53988   arg2 = (float)jarg2;
53989   {
53990     try {
53991       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
53992     } catch (std::out_of_range& e) {
53993       {
53994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53995       };
53996     } catch (std::exception& e) {
53997       {
53998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53999       };
54000     } catch (Dali::DaliException e) {
54001       {
54002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54003       };
54004     } catch (...) {
54005       {
54006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54007       };
54008     }
54009   }
54010
54011 }
54012
54013
54014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
54015   void * jresult ;
54016   Dali::Signal< void (float) > *result = 0 ;
54017
54018   {
54019     try {
54020       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
54021     } catch (std::out_of_range& e) {
54022       {
54023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54024       };
54025     } catch (std::exception& e) {
54026       {
54027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54028       };
54029     } catch (Dali::DaliException e) {
54030       {
54031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54032       };
54033     } catch (...) {
54034       {
54035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54036       };
54037     }
54038   }
54039
54040   jresult = (void *)result;
54041   return jresult;
54042 }
54043
54044
54045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
54046   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
54047
54048   arg1 = (Dali::Signal< void (float) > *)jarg1;
54049   {
54050     try {
54051       delete arg1;
54052     } catch (std::out_of_range& e) {
54053       {
54054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54055       };
54056     } catch (std::exception& e) {
54057       {
54058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54059       };
54060     } catch (Dali::DaliException e) {
54061       {
54062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54063       };
54064     } catch (...) {
54065       {
54066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54067       };
54068     }
54069   }
54070
54071 }
54072
54073
54074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
54075   unsigned int jresult ;
54076   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54077   bool result;
54078
54079   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54080   {
54081     try {
54082       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54083     } catch (std::out_of_range& e) {
54084       {
54085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54086       };
54087     } catch (std::exception& e) {
54088       {
54089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54090       };
54091     } catch (Dali::DaliException e) {
54092       {
54093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54094       };
54095     } catch (...) {
54096       {
54097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54098       };
54099     }
54100   }
54101
54102   jresult = result;
54103   return jresult;
54104 }
54105
54106
54107 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
54108   unsigned long jresult ;
54109   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54110   std::size_t result;
54111
54112   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54113   {
54114     try {
54115       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
54116     } catch (std::out_of_range& e) {
54117       {
54118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54119       };
54120     } catch (std::exception& e) {
54121       {
54122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54123       };
54124     } catch (Dali::DaliException e) {
54125       {
54126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54127       };
54128     } catch (...) {
54129       {
54130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54131       };
54132     }
54133   }
54134
54135   jresult = (unsigned long)result;
54136   return jresult;
54137 }
54138
54139
54140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
54141   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54142   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54143
54144   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54145   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54146   {
54147     try {
54148       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
54149     } catch (std::out_of_range& e) {
54150       {
54151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54152       };
54153     } catch (std::exception& e) {
54154       {
54155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54156       };
54157     } catch (Dali::DaliException e) {
54158       {
54159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54160       };
54161     } catch (...) {
54162       {
54163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54164       };
54165     }
54166   }
54167
54168 }
54169
54170
54171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
54172   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54173   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
54174
54175   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54176   arg2 = (void (*)(Dali::BaseHandle))jarg2;
54177   {
54178     try {
54179       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
54180     } catch (std::out_of_range& e) {
54181       {
54182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54183       };
54184     } catch (std::exception& e) {
54185       {
54186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54187       };
54188     } catch (Dali::DaliException e) {
54189       {
54190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54191       };
54192     } catch (...) {
54193       {
54194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54195       };
54196     }
54197   }
54198
54199 }
54200
54201
54202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
54203   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54204   Dali::BaseHandle arg2 ;
54205   Dali::BaseHandle *argp2 ;
54206
54207   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54208   argp2 = (Dali::BaseHandle *)jarg2;
54209   if (!argp2) {
54210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54211     return ;
54212   }
54213   arg2 = *argp2;
54214   {
54215     try {
54216       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
54217     } catch (std::out_of_range& e) {
54218       {
54219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54220       };
54221     } catch (std::exception& e) {
54222       {
54223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54224       };
54225     } catch (Dali::DaliException e) {
54226       {
54227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54228       };
54229     } catch (...) {
54230       {
54231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54232       };
54233     }
54234   }
54235
54236 }
54237
54238
54239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
54240   void * jresult ;
54241   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
54242
54243   {
54244     try {
54245       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
54246     } catch (std::out_of_range& e) {
54247       {
54248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54249       };
54250     } catch (std::exception& e) {
54251       {
54252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54253       };
54254     } catch (Dali::DaliException e) {
54255       {
54256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54257       };
54258     } catch (...) {
54259       {
54260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54261       };
54262     }
54263   }
54264
54265   jresult = (void *)result;
54266   return jresult;
54267 }
54268
54269
54270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
54271   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
54272
54273   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
54274   {
54275     try {
54276       delete arg1;
54277     } catch (std::out_of_range& e) {
54278       {
54279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54280       };
54281     } catch (std::exception& e) {
54282       {
54283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54284       };
54285     } catch (Dali::DaliException e) {
54286       {
54287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54288       };
54289     } catch (...) {
54290       {
54291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54292       };
54293     }
54294   }
54295
54296 }
54297
54298
54299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
54300   unsigned int jresult ;
54301   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54302   bool result;
54303
54304   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54305   {
54306     try {
54307       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54308     } catch (std::out_of_range& e) {
54309       {
54310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54311       };
54312     } catch (std::exception& e) {
54313       {
54314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54315       };
54316     } catch (Dali::DaliException e) {
54317       {
54318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54319       };
54320     } catch (...) {
54321       {
54322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54323       };
54324     }
54325   }
54326
54327   jresult = result;
54328   return jresult;
54329 }
54330
54331
54332 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
54333   unsigned long jresult ;
54334   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54335   std::size_t result;
54336
54337   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54338   {
54339     try {
54340       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
54341     } catch (std::out_of_range& e) {
54342       {
54343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54344       };
54345     } catch (std::exception& e) {
54346       {
54347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54348       };
54349     } catch (Dali::DaliException e) {
54350       {
54351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54352       };
54353     } catch (...) {
54354       {
54355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54356       };
54357     }
54358   }
54359
54360   jresult = (unsigned long)result;
54361   return jresult;
54362 }
54363
54364
54365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
54366   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54367   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54368
54369   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54370   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54371   {
54372     try {
54373       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
54374     } catch (std::out_of_range& e) {
54375       {
54376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54377       };
54378     } catch (std::exception& e) {
54379       {
54380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54381       };
54382     } catch (Dali::DaliException e) {
54383       {
54384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54385       };
54386     } catch (...) {
54387       {
54388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54389       };
54390     }
54391   }
54392
54393 }
54394
54395
54396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
54397   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54398   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
54399
54400   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54401   arg2 = (void (*)(Dali::RefObject const *))jarg2;
54402   {
54403     try {
54404       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
54405     } catch (std::out_of_range& e) {
54406       {
54407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54408       };
54409     } catch (std::exception& e) {
54410       {
54411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54412       };
54413     } catch (Dali::DaliException e) {
54414       {
54415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54416       };
54417     } catch (...) {
54418       {
54419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54420       };
54421     }
54422   }
54423
54424 }
54425
54426
54427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
54428   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54429   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
54430
54431   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54432   arg2 = (Dali::RefObject *)jarg2;
54433   {
54434     try {
54435       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
54436     } catch (std::out_of_range& e) {
54437       {
54438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54439       };
54440     } catch (std::exception& e) {
54441       {
54442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54443       };
54444     } catch (Dali::DaliException e) {
54445       {
54446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54447       };
54448     } catch (...) {
54449       {
54450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54451       };
54452     }
54453   }
54454
54455 }
54456
54457
54458 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
54459   void * jresult ;
54460   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
54461
54462   {
54463     try {
54464       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
54465     } catch (std::out_of_range& e) {
54466       {
54467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54468       };
54469     } catch (std::exception& e) {
54470       {
54471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54472       };
54473     } catch (Dali::DaliException e) {
54474       {
54475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54476       };
54477     } catch (...) {
54478       {
54479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54480       };
54481     }
54482   }
54483
54484   jresult = (void *)result;
54485   return jresult;
54486 }
54487
54488
54489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
54490   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
54491
54492   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
54493   {
54494     try {
54495       delete arg1;
54496     } catch (std::out_of_range& e) {
54497       {
54498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54499       };
54500     } catch (std::exception& e) {
54501       {
54502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54503       };
54504     } catch (Dali::DaliException e) {
54505       {
54506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54507       };
54508     } catch (...) {
54509       {
54510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54511       };
54512     }
54513   }
54514
54515 }
54516
54517
54518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
54519   unsigned int jresult ;
54520   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54521   bool result;
54522
54523   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54524   {
54525     try {
54526       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54527     } catch (std::out_of_range& e) {
54528       {
54529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54530       };
54531     } catch (std::exception& e) {
54532       {
54533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54534       };
54535     } catch (Dali::DaliException e) {
54536       {
54537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54538       };
54539     } catch (...) {
54540       {
54541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54542       };
54543     }
54544   }
54545
54546   jresult = result;
54547   return jresult;
54548 }
54549
54550
54551 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
54552   unsigned long jresult ;
54553   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54554   std::size_t result;
54555
54556   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54557   {
54558     try {
54559       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
54560     } catch (std::out_of_range& e) {
54561       {
54562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54563       };
54564     } catch (std::exception& e) {
54565       {
54566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54567       };
54568     } catch (Dali::DaliException e) {
54569       {
54570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54571       };
54572     } catch (...) {
54573       {
54574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54575       };
54576     }
54577   }
54578
54579   jresult = (unsigned long)result;
54580   return jresult;
54581 }
54582
54583
54584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
54585   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54586   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54587
54588   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54589   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54590   {
54591     try {
54592       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
54593     } catch (std::out_of_range& e) {
54594       {
54595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54596       };
54597     } catch (std::exception& e) {
54598       {
54599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54600       };
54601     } catch (Dali::DaliException e) {
54602       {
54603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54604       };
54605     } catch (...) {
54606       {
54607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54608       };
54609     }
54610   }
54611
54612 }
54613
54614
54615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
54616   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54617   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
54618
54619   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54620   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
54621   {
54622     try {
54623       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
54624     } catch (std::out_of_range& e) {
54625       {
54626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54627       };
54628     } catch (std::exception& e) {
54629       {
54630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54631       };
54632     } catch (Dali::DaliException e) {
54633       {
54634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54635       };
54636     } catch (...) {
54637       {
54638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54639       };
54640     }
54641   }
54642
54643 }
54644
54645
54646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
54647   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54648   Dali::PropertyNotification *arg2 = 0 ;
54649
54650   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54651   arg2 = (Dali::PropertyNotification *)jarg2;
54652   if (!arg2) {
54653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
54654     return ;
54655   }
54656   {
54657     try {
54658       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
54659     } catch (std::out_of_range& e) {
54660       {
54661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54662       };
54663     } catch (std::exception& e) {
54664       {
54665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54666       };
54667     } catch (Dali::DaliException e) {
54668       {
54669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54670       };
54671     } catch (...) {
54672       {
54673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54674       };
54675     }
54676   }
54677
54678 }
54679
54680
54681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
54682   void * jresult ;
54683   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
54684
54685   {
54686     try {
54687       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
54688     } catch (std::out_of_range& e) {
54689       {
54690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54691       };
54692     } catch (std::exception& e) {
54693       {
54694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54695       };
54696     } catch (Dali::DaliException e) {
54697       {
54698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54699       };
54700     } catch (...) {
54701       {
54702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54703       };
54704     }
54705   }
54706
54707   jresult = (void *)result;
54708   return jresult;
54709 }
54710
54711
54712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
54713   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
54714
54715   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
54716   {
54717     try {
54718       delete arg1;
54719     } catch (std::out_of_range& e) {
54720       {
54721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54722       };
54723     } catch (std::exception& e) {
54724       {
54725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54726       };
54727     } catch (Dali::DaliException e) {
54728       {
54729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54730       };
54731     } catch (...) {
54732       {
54733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54734       };
54735     }
54736   }
54737
54738 }
54739
54740
54741 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
54742   unsigned int jresult ;
54743   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54744   bool result;
54745
54746   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54747   {
54748     try {
54749       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
54750     } catch (std::out_of_range& e) {
54751       {
54752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54753       };
54754     } catch (std::exception& e) {
54755       {
54756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54757       };
54758     } catch (Dali::DaliException e) {
54759       {
54760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54761       };
54762     } catch (...) {
54763       {
54764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54765       };
54766     }
54767   }
54768
54769   jresult = result;
54770   return jresult;
54771 }
54772
54773
54774 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
54775   unsigned long jresult ;
54776   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54777   std::size_t result;
54778
54779   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54780   {
54781     try {
54782       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
54783     } catch (std::out_of_range& e) {
54784       {
54785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54786       };
54787     } catch (std::exception& e) {
54788       {
54789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54790       };
54791     } catch (Dali::DaliException e) {
54792       {
54793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54794       };
54795     } catch (...) {
54796       {
54797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54798       };
54799     }
54800   }
54801
54802   jresult = (unsigned long)result;
54803   return jresult;
54804 }
54805
54806
54807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
54808   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54809   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54810
54811   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54812   arg2 = (void (*)(Dali::Image))jarg2;
54813   {
54814     try {
54815       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
54816     } catch (std::out_of_range& e) {
54817       {
54818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54819       };
54820     } catch (std::exception& e) {
54821       {
54822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54823       };
54824     } catch (Dali::DaliException e) {
54825       {
54826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54827       };
54828     } catch (...) {
54829       {
54830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54831       };
54832     }
54833   }
54834
54835 }
54836
54837
54838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
54839   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54840   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
54841
54842   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54843   arg2 = (void (*)(Dali::Image))jarg2;
54844   {
54845     try {
54846       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
54847     } catch (std::out_of_range& e) {
54848       {
54849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54850       };
54851     } catch (std::exception& e) {
54852       {
54853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54854       };
54855     } catch (Dali::DaliException e) {
54856       {
54857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54858       };
54859     } catch (...) {
54860       {
54861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54862       };
54863     }
54864   }
54865
54866 }
54867
54868
54869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
54870   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54871   Dali::Image arg2 ;
54872   Dali::Image *argp2 ;
54873
54874   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54875   argp2 = (Dali::Image *)jarg2;
54876   if (!argp2) {
54877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
54878     return ;
54879   }
54880   arg2 = *argp2;
54881   {
54882     try {
54883       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
54884     } catch (std::out_of_range& e) {
54885       {
54886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54887       };
54888     } catch (std::exception& e) {
54889       {
54890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54891       };
54892     } catch (Dali::DaliException e) {
54893       {
54894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54895       };
54896     } catch (...) {
54897       {
54898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54899       };
54900     }
54901   }
54902
54903 }
54904
54905
54906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
54907   void * jresult ;
54908   Dali::Signal< void (Dali::Image) > *result = 0 ;
54909
54910   {
54911     try {
54912       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
54913     } catch (std::out_of_range& e) {
54914       {
54915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54916       };
54917     } catch (std::exception& e) {
54918       {
54919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54920       };
54921     } catch (Dali::DaliException e) {
54922       {
54923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54924       };
54925     } catch (...) {
54926       {
54927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54928       };
54929     }
54930   }
54931
54932   jresult = (void *)result;
54933   return jresult;
54934 }
54935
54936
54937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
54938   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
54939
54940   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
54941   {
54942     try {
54943       delete arg1;
54944     } catch (std::out_of_range& e) {
54945       {
54946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54947       };
54948     } catch (std::exception& e) {
54949       {
54950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54951       };
54952     } catch (Dali::DaliException e) {
54953       {
54954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54955       };
54956     } catch (...) {
54957       {
54958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54959       };
54960     }
54961   }
54962
54963 }
54964
54965
54966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
54967   void * jresult ;
54968   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
54969
54970   {
54971     try {
54972       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
54973     } catch (std::out_of_range& e) {
54974       {
54975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54976       };
54977     } catch (std::exception& e) {
54978       {
54979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54980       };
54981     } catch (Dali::DaliException e) {
54982       {
54983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54984       };
54985     } catch (...) {
54986       {
54987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54988       };
54989     }
54990   }
54991
54992   jresult = (void *)result;
54993   return jresult;
54994 }
54995
54996
54997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
54998   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
54999
55000   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
55001   {
55002     try {
55003       delete arg1;
55004     } catch (std::out_of_range& e) {
55005       {
55006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55007       };
55008     } catch (std::exception& e) {
55009       {
55010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55011       };
55012     } catch (Dali::DaliException e) {
55013       {
55014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55015       };
55016     } catch (...) {
55017       {
55018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55019       };
55020     }
55021   }
55022
55023 }
55024
55025
55026 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
55027   unsigned int jresult ;
55028   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55029   bool result;
55030
55031   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55032   {
55033     try {
55034       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);
55035     } catch (std::out_of_range& e) {
55036       {
55037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55038       };
55039     } catch (std::exception& e) {
55040       {
55041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55042       };
55043     } catch (Dali::DaliException e) {
55044       {
55045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55046       };
55047     } catch (...) {
55048       {
55049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55050       };
55051     }
55052   }
55053
55054   jresult = result;
55055   return jresult;
55056 }
55057
55058
55059 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55060   unsigned long jresult ;
55061   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55062   std::size_t result;
55063
55064   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55065   {
55066     try {
55067       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);
55068     } catch (std::out_of_range& e) {
55069       {
55070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55071       };
55072     } catch (std::exception& e) {
55073       {
55074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55075       };
55076     } catch (Dali::DaliException e) {
55077       {
55078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55079       };
55080     } catch (...) {
55081       {
55082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55083       };
55084     }
55085   }
55086
55087   jresult = (unsigned long)result;
55088   return jresult;
55089 }
55090
55091
55092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55093   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55094   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55095
55096   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55097   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55098   {
55099     try {
55100       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55101     } catch (std::out_of_range& e) {
55102       {
55103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55104       };
55105     } catch (std::exception& e) {
55106       {
55107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55108       };
55109     } catch (Dali::DaliException e) {
55110       {
55111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55112       };
55113     } catch (...) {
55114       {
55115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55116       };
55117     }
55118   }
55119
55120 }
55121
55122
55123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55124   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55125   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
55126
55127   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55128   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
55129   {
55130     try {
55131       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55132     } catch (std::out_of_range& e) {
55133       {
55134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55135       };
55136     } catch (std::exception& e) {
55137       {
55138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55139       };
55140     } catch (Dali::DaliException e) {
55141       {
55142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55143       };
55144     } catch (...) {
55145       {
55146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55147       };
55148     }
55149   }
55150
55151 }
55152
55153
55154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55155   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55156   Dali::Actor arg2 ;
55157   Dali::LongPressGesture *arg3 = 0 ;
55158   Dali::Actor *argp2 ;
55159
55160   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55161   argp2 = (Dali::Actor *)jarg2;
55162   if (!argp2) {
55163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55164     return ;
55165   }
55166   arg2 = *argp2;
55167   arg3 = (Dali::LongPressGesture *)jarg3;
55168   if (!arg3) {
55169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
55170     return ;
55171   }
55172   {
55173     try {
55174       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
55175     } catch (std::out_of_range& e) {
55176       {
55177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55178       };
55179     } catch (std::exception& e) {
55180       {
55181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55182       };
55183     } catch (Dali::DaliException e) {
55184       {
55185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55186       };
55187     } catch (...) {
55188       {
55189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55190       };
55191     }
55192   }
55193
55194 }
55195
55196
55197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
55198   void * jresult ;
55199   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
55200
55201   {
55202     try {
55203       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
55204     } catch (std::out_of_range& e) {
55205       {
55206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55207       };
55208     } catch (std::exception& e) {
55209       {
55210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55211       };
55212     } catch (Dali::DaliException e) {
55213       {
55214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55215       };
55216     } catch (...) {
55217       {
55218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55219       };
55220     }
55221   }
55222
55223   jresult = (void *)result;
55224   return jresult;
55225 }
55226
55227
55228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
55229   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
55230
55231   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
55232   {
55233     try {
55234       delete arg1;
55235     } catch (std::out_of_range& e) {
55236       {
55237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55238       };
55239     } catch (std::exception& e) {
55240       {
55241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55242       };
55243     } catch (Dali::DaliException e) {
55244       {
55245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55246       };
55247     } catch (...) {
55248       {
55249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55250       };
55251     }
55252   }
55253
55254 }
55255
55256
55257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
55258   unsigned int jresult ;
55259   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55260   bool result;
55261
55262   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55263   {
55264     try {
55265       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);
55266     } catch (std::out_of_range& e) {
55267       {
55268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55269       };
55270     } catch (std::exception& e) {
55271       {
55272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55273       };
55274     } catch (Dali::DaliException e) {
55275       {
55276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55277       };
55278     } catch (...) {
55279       {
55280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55281       };
55282     }
55283   }
55284
55285   jresult = result;
55286   return jresult;
55287 }
55288
55289
55290 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
55291   unsigned long jresult ;
55292   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55293   std::size_t result;
55294
55295   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55296   {
55297     try {
55298       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);
55299     } catch (std::out_of_range& e) {
55300       {
55301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55302       };
55303     } catch (std::exception& e) {
55304       {
55305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55306       };
55307     } catch (Dali::DaliException e) {
55308       {
55309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55310       };
55311     } catch (...) {
55312       {
55313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55314       };
55315     }
55316   }
55317
55318   jresult = (unsigned long)result;
55319   return jresult;
55320 }
55321
55322
55323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
55324   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55325   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55326
55327   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55328   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55329   {
55330     try {
55331       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55332     } catch (std::out_of_range& e) {
55333       {
55334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55335       };
55336     } catch (std::exception& e) {
55337       {
55338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55339       };
55340     } catch (Dali::DaliException e) {
55341       {
55342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55343       };
55344     } catch (...) {
55345       {
55346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55347       };
55348     }
55349   }
55350
55351 }
55352
55353
55354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
55355   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55356   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
55357
55358   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55359   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
55360   {
55361     try {
55362       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55363     } catch (std::out_of_range& e) {
55364       {
55365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55366       };
55367     } catch (std::exception& e) {
55368       {
55369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55370       };
55371     } catch (Dali::DaliException e) {
55372       {
55373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55374       };
55375     } catch (...) {
55376       {
55377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55378       };
55379     }
55380   }
55381
55382 }
55383
55384
55385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55386   unsigned int jresult ;
55387   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55388   Dali::Actor arg2 ;
55389   Dali::TouchData *arg3 = 0 ;
55390   Dali::Actor *argp2 ;
55391   bool result;
55392
55393   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55394   argp2 = (Dali::Actor *)jarg2;
55395   if (!argp2) {
55396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55397     return 0;
55398   }
55399   arg2 = *argp2;
55400   arg3 = (Dali::TouchData *)jarg3;
55401   if (!arg3) {
55402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55403     return 0;
55404   }
55405   {
55406     try {
55407       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
55408     } catch (std::out_of_range& e) {
55409       {
55410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55411       };
55412     } catch (std::exception& e) {
55413       {
55414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55415       };
55416     } catch (Dali::DaliException e) {
55417       {
55418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55419       };
55420     } catch (...) {
55421       {
55422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55423       };
55424     }
55425   }
55426
55427   jresult = result;
55428   return jresult;
55429 }
55430
55431
55432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
55433   void * jresult ;
55434   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
55435
55436   {
55437     try {
55438       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
55439     } catch (std::out_of_range& e) {
55440       {
55441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55442       };
55443     } catch (std::exception& e) {
55444       {
55445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55446       };
55447     } catch (Dali::DaliException e) {
55448       {
55449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55450       };
55451     } catch (...) {
55452       {
55453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55454       };
55455     }
55456   }
55457
55458   jresult = (void *)result;
55459   return jresult;
55460 }
55461
55462
55463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
55464   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
55465
55466   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
55467   {
55468     try {
55469       delete arg1;
55470     } catch (std::out_of_range& e) {
55471       {
55472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55473       };
55474     } catch (std::exception& e) {
55475       {
55476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55477       };
55478     } catch (Dali::DaliException e) {
55479       {
55480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55481       };
55482     } catch (...) {
55483       {
55484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55485       };
55486     }
55487   }
55488
55489 }
55490
55491
55492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
55493   unsigned int jresult ;
55494   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55495   bool result;
55496
55497   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55498   {
55499     try {
55500       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);
55501     } catch (std::out_of_range& e) {
55502       {
55503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55504       };
55505     } catch (std::exception& e) {
55506       {
55507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55508       };
55509     } catch (Dali::DaliException e) {
55510       {
55511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55512       };
55513     } catch (...) {
55514       {
55515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55516       };
55517     }
55518   }
55519
55520   jresult = result;
55521   return jresult;
55522 }
55523
55524
55525 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
55526   unsigned long jresult ;
55527   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55528   std::size_t result;
55529
55530   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55531   {
55532     try {
55533       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);
55534     } catch (std::out_of_range& e) {
55535       {
55536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55537       };
55538     } catch (std::exception& e) {
55539       {
55540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55541       };
55542     } catch (Dali::DaliException e) {
55543       {
55544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55545       };
55546     } catch (...) {
55547       {
55548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55549       };
55550     }
55551   }
55552
55553   jresult = (unsigned long)result;
55554   return jresult;
55555 }
55556
55557
55558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
55559   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55560   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55561
55562   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55563   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55564   {
55565     try {
55566       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55567     } catch (std::out_of_range& e) {
55568       {
55569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55570       };
55571     } catch (std::exception& e) {
55572       {
55573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55574       };
55575     } catch (Dali::DaliException e) {
55576       {
55577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55578       };
55579     } catch (...) {
55580       {
55581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55582       };
55583     }
55584   }
55585
55586 }
55587
55588
55589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
55590   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55591   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
55592
55593   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55594   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
55595   {
55596     try {
55597       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55598     } catch (std::out_of_range& e) {
55599       {
55600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55601       };
55602     } catch (std::exception& e) {
55603       {
55604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55605       };
55606     } catch (Dali::DaliException e) {
55607       {
55608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55609       };
55610     } catch (...) {
55611       {
55612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55613       };
55614     }
55615   }
55616
55617 }
55618
55619
55620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55621   unsigned int jresult ;
55622   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55623   Dali::Actor arg2 ;
55624   Dali::HoverEvent *arg3 = 0 ;
55625   Dali::Actor *argp2 ;
55626   bool result;
55627
55628   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55629   argp2 = (Dali::Actor *)jarg2;
55630   if (!argp2) {
55631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55632     return 0;
55633   }
55634   arg2 = *argp2;
55635   arg3 = (Dali::HoverEvent *)jarg3;
55636   if (!arg3) {
55637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
55638     return 0;
55639   }
55640   {
55641     try {
55642       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
55643     } catch (std::out_of_range& e) {
55644       {
55645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55646       };
55647     } catch (std::exception& e) {
55648       {
55649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55650       };
55651     } catch (Dali::DaliException e) {
55652       {
55653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55654       };
55655     } catch (...) {
55656       {
55657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55658       };
55659     }
55660   }
55661
55662   jresult = result;
55663   return jresult;
55664 }
55665
55666
55667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
55668   void * jresult ;
55669   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
55670
55671   {
55672     try {
55673       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
55674     } catch (std::out_of_range& e) {
55675       {
55676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55677       };
55678     } catch (std::exception& e) {
55679       {
55680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55681       };
55682     } catch (Dali::DaliException e) {
55683       {
55684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55685       };
55686     } catch (...) {
55687       {
55688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55689       };
55690     }
55691   }
55692
55693   jresult = (void *)result;
55694   return jresult;
55695 }
55696
55697
55698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
55699   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
55700
55701   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
55702   {
55703     try {
55704       delete arg1;
55705     } catch (std::out_of_range& e) {
55706       {
55707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55708       };
55709     } catch (std::exception& e) {
55710       {
55711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55712       };
55713     } catch (Dali::DaliException e) {
55714       {
55715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55716       };
55717     } catch (...) {
55718       {
55719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55720       };
55721     }
55722   }
55723
55724 }
55725
55726
55727 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
55728   unsigned int jresult ;
55729   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55730   bool result;
55731
55732   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55733   {
55734     try {
55735       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);
55736     } catch (std::out_of_range& e) {
55737       {
55738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55739       };
55740     } catch (std::exception& e) {
55741       {
55742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55743       };
55744     } catch (Dali::DaliException e) {
55745       {
55746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55747       };
55748     } catch (...) {
55749       {
55750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55751       };
55752     }
55753   }
55754
55755   jresult = result;
55756   return jresult;
55757 }
55758
55759
55760 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
55761   unsigned long jresult ;
55762   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55763   std::size_t result;
55764
55765   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55766   {
55767     try {
55768       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);
55769     } catch (std::out_of_range& e) {
55770       {
55771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55772       };
55773     } catch (std::exception& e) {
55774       {
55775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55776       };
55777     } catch (Dali::DaliException e) {
55778       {
55779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55780       };
55781     } catch (...) {
55782       {
55783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55784       };
55785     }
55786   }
55787
55788   jresult = (unsigned long)result;
55789   return jresult;
55790 }
55791
55792
55793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
55794   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55795   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55796
55797   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55798   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55799   {
55800     try {
55801       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55802     } catch (std::out_of_range& e) {
55803       {
55804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55805       };
55806     } catch (std::exception& e) {
55807       {
55808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55809       };
55810     } catch (Dali::DaliException e) {
55811       {
55812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55813       };
55814     } catch (...) {
55815       {
55816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55817       };
55818     }
55819   }
55820
55821 }
55822
55823
55824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55825   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55826   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
55827
55828   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55829   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
55830   {
55831     try {
55832       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55833     } catch (std::out_of_range& e) {
55834       {
55835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55836       };
55837     } catch (std::exception& e) {
55838       {
55839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55840       };
55841     } catch (Dali::DaliException e) {
55842       {
55843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55844       };
55845     } catch (...) {
55846       {
55847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55848       };
55849     }
55850   }
55851
55852 }
55853
55854
55855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55856   unsigned int jresult ;
55857   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55858   Dali::Actor arg2 ;
55859   Dali::WheelEvent *arg3 = 0 ;
55860   Dali::Actor *argp2 ;
55861   bool result;
55862
55863   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55864   argp2 = (Dali::Actor *)jarg2;
55865   if (!argp2) {
55866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55867     return 0;
55868   }
55869   arg2 = *argp2;
55870   arg3 = (Dali::WheelEvent *)jarg3;
55871   if (!arg3) {
55872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55873     return 0;
55874   }
55875   {
55876     try {
55877       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
55878     } catch (std::out_of_range& e) {
55879       {
55880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55881       };
55882     } catch (std::exception& e) {
55883       {
55884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55885       };
55886     } catch (Dali::DaliException e) {
55887       {
55888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55889       };
55890     } catch (...) {
55891       {
55892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55893       };
55894     }
55895   }
55896
55897   jresult = result;
55898   return jresult;
55899 }
55900
55901
55902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
55903   void * jresult ;
55904   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
55905
55906   {
55907     try {
55908       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
55909     } catch (std::out_of_range& e) {
55910       {
55911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55912       };
55913     } catch (std::exception& e) {
55914       {
55915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55916       };
55917     } catch (Dali::DaliException e) {
55918       {
55919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55920       };
55921     } catch (...) {
55922       {
55923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55924       };
55925     }
55926   }
55927
55928   jresult = (void *)result;
55929   return jresult;
55930 }
55931
55932
55933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
55934   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
55935
55936   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
55937   {
55938     try {
55939       delete arg1;
55940     } catch (std::out_of_range& e) {
55941       {
55942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55943       };
55944     } catch (std::exception& e) {
55945       {
55946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55947       };
55948     } catch (Dali::DaliException e) {
55949       {
55950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55951       };
55952     } catch (...) {
55953       {
55954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55955       };
55956     }
55957   }
55958
55959 }
55960
55961
55962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
55963   unsigned int jresult ;
55964   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55965   bool result;
55966
55967   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
55968   {
55969     try {
55970       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
55971     } catch (std::out_of_range& e) {
55972       {
55973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55974       };
55975     } catch (std::exception& e) {
55976       {
55977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55978       };
55979     } catch (Dali::DaliException e) {
55980       {
55981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55982       };
55983     } catch (...) {
55984       {
55985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55986       };
55987     }
55988   }
55989
55990   jresult = result;
55991   return jresult;
55992 }
55993
55994
55995 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
55996   unsigned long jresult ;
55997   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
55998   std::size_t result;
55999
56000   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56001   {
56002     try {
56003       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
56004     } catch (std::out_of_range& e) {
56005       {
56006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56007       };
56008     } catch (std::exception& e) {
56009       {
56010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56011       };
56012     } catch (Dali::DaliException e) {
56013       {
56014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56015       };
56016     } catch (...) {
56017       {
56018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56019       };
56020     }
56021   }
56022
56023   jresult = (unsigned long)result;
56024   return jresult;
56025 }
56026
56027
56028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
56029   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56030   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56031
56032   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56033   arg2 = (void (*)(Dali::Actor))jarg2;
56034   {
56035     try {
56036       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
56037     } catch (std::out_of_range& e) {
56038       {
56039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56040       };
56041     } catch (std::exception& e) {
56042       {
56043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56044       };
56045     } catch (Dali::DaliException e) {
56046       {
56047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56048       };
56049     } catch (...) {
56050       {
56051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56052       };
56053     }
56054   }
56055
56056 }
56057
56058
56059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
56060   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56061   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
56062
56063   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56064   arg2 = (void (*)(Dali::Actor))jarg2;
56065   {
56066     try {
56067       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
56068     } catch (std::out_of_range& e) {
56069       {
56070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56071       };
56072     } catch (std::exception& e) {
56073       {
56074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56075       };
56076     } catch (Dali::DaliException e) {
56077       {
56078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56079       };
56080     } catch (...) {
56081       {
56082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56083       };
56084     }
56085   }
56086
56087 }
56088
56089
56090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
56091   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56092   Dali::Actor arg2 ;
56093   Dali::Actor *argp2 ;
56094
56095   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56096   argp2 = (Dali::Actor *)jarg2;
56097   if (!argp2) {
56098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56099     return ;
56100   }
56101   arg2 = *argp2;
56102   {
56103     try {
56104       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
56105     } catch (std::out_of_range& e) {
56106       {
56107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56108       };
56109     } catch (std::exception& e) {
56110       {
56111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56112       };
56113     } catch (Dali::DaliException e) {
56114       {
56115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56116       };
56117     } catch (...) {
56118       {
56119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56120       };
56121     }
56122   }
56123
56124 }
56125
56126
56127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
56128   void * jresult ;
56129   Dali::Signal< void (Dali::Actor) > *result = 0 ;
56130
56131   {
56132     try {
56133       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
56134     } catch (std::out_of_range& e) {
56135       {
56136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56137       };
56138     } catch (std::exception& e) {
56139       {
56140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56141       };
56142     } catch (Dali::DaliException e) {
56143       {
56144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56145       };
56146     } catch (...) {
56147       {
56148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56149       };
56150     }
56151   }
56152
56153   jresult = (void *)result;
56154   return jresult;
56155 }
56156
56157
56158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
56159   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
56160
56161   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
56162   {
56163     try {
56164       delete arg1;
56165     } catch (std::out_of_range& e) {
56166       {
56167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56168       };
56169     } catch (std::exception& e) {
56170       {
56171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56172       };
56173     } catch (Dali::DaliException e) {
56174       {
56175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56176       };
56177     } catch (...) {
56178       {
56179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56180       };
56181     }
56182   }
56183
56184 }
56185
56186
56187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
56188   unsigned int jresult ;
56189   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56190   bool result;
56191
56192   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56193   {
56194     try {
56195       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56196     } catch (std::out_of_range& e) {
56197       {
56198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56199       };
56200     } catch (std::exception& e) {
56201       {
56202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56203       };
56204     } catch (Dali::DaliException e) {
56205       {
56206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56207       };
56208     } catch (...) {
56209       {
56210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56211       };
56212     }
56213   }
56214
56215   jresult = result;
56216   return jresult;
56217 }
56218
56219
56220 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
56221   unsigned long jresult ;
56222   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56223   std::size_t result;
56224
56225   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56226   {
56227     try {
56228       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
56229     } catch (std::out_of_range& e) {
56230       {
56231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56232       };
56233     } catch (std::exception& e) {
56234       {
56235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56236       };
56237     } catch (Dali::DaliException e) {
56238       {
56239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56240       };
56241     } catch (...) {
56242       {
56243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56244       };
56245     }
56246   }
56247
56248   jresult = (unsigned long)result;
56249   return jresult;
56250 }
56251
56252
56253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
56254   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56255   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56256
56257   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56258   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56259   {
56260     try {
56261       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56262     } catch (std::out_of_range& e) {
56263       {
56264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56265       };
56266     } catch (std::exception& e) {
56267       {
56268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56269       };
56270     } catch (Dali::DaliException e) {
56271       {
56272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56273       };
56274     } catch (...) {
56275       {
56276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56277       };
56278     }
56279   }
56280
56281 }
56282
56283
56284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
56285   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56286   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
56287
56288   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56289   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
56290   {
56291     try {
56292       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56293     } catch (std::out_of_range& e) {
56294       {
56295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56296       };
56297     } catch (std::exception& e) {
56298       {
56299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56300       };
56301     } catch (Dali::DaliException e) {
56302       {
56303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56304       };
56305     } catch (...) {
56306       {
56307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56308       };
56309     }
56310   }
56311
56312 }
56313
56314
56315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
56316   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56317   Dali::KeyEvent *arg2 = 0 ;
56318
56319   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56320   arg2 = (Dali::KeyEvent *)jarg2;
56321   if (!arg2) {
56322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
56323     return ;
56324   }
56325   {
56326     try {
56327       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
56328     } catch (std::out_of_range& e) {
56329       {
56330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56331       };
56332     } catch (std::exception& e) {
56333       {
56334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56335       };
56336     } catch (Dali::DaliException e) {
56337       {
56338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56339       };
56340     } catch (...) {
56341       {
56342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56343       };
56344     }
56345   }
56346
56347 }
56348
56349
56350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
56351   void * jresult ;
56352   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
56353
56354   {
56355     try {
56356       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
56357     } catch (std::out_of_range& e) {
56358       {
56359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56360       };
56361     } catch (std::exception& e) {
56362       {
56363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56364       };
56365     } catch (Dali::DaliException e) {
56366       {
56367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56368       };
56369     } catch (...) {
56370       {
56371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56372       };
56373     }
56374   }
56375
56376   jresult = (void *)result;
56377   return jresult;
56378 }
56379
56380
56381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
56382   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
56383
56384   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
56385   {
56386     try {
56387       delete arg1;
56388     } catch (std::out_of_range& e) {
56389       {
56390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56391       };
56392     } catch (std::exception& e) {
56393       {
56394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56395       };
56396     } catch (Dali::DaliException e) {
56397       {
56398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56399       };
56400     } catch (...) {
56401       {
56402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56403       };
56404     }
56405   }
56406
56407 }
56408
56409
56410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
56411   unsigned int jresult ;
56412   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56413   bool result;
56414
56415   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56416   {
56417     try {
56418       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56419     } catch (std::out_of_range& e) {
56420       {
56421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56422       };
56423     } catch (std::exception& e) {
56424       {
56425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56426       };
56427     } catch (Dali::DaliException e) {
56428       {
56429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56430       };
56431     } catch (...) {
56432       {
56433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56434       };
56435     }
56436   }
56437
56438   jresult = result;
56439   return jresult;
56440 }
56441
56442
56443 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
56444   unsigned long jresult ;
56445   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56446   std::size_t result;
56447
56448   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56449   {
56450     try {
56451       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
56452     } catch (std::out_of_range& e) {
56453       {
56454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56455       };
56456     } catch (std::exception& e) {
56457       {
56458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56459       };
56460     } catch (Dali::DaliException e) {
56461       {
56462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56463       };
56464     } catch (...) {
56465       {
56466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56467       };
56468     }
56469   }
56470
56471   jresult = (unsigned long)result;
56472   return jresult;
56473 }
56474
56475
56476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
56477   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56478   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56479
56480   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56481   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56482   {
56483     try {
56484       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56485     } catch (std::out_of_range& e) {
56486       {
56487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56488       };
56489     } catch (std::exception& e) {
56490       {
56491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56492       };
56493     } catch (Dali::DaliException e) {
56494       {
56495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56496       };
56497     } catch (...) {
56498       {
56499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56500       };
56501     }
56502   }
56503
56504 }
56505
56506
56507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
56508   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56509   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
56510
56511   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56512   arg2 = (void (*)(Dali::TouchData const &))jarg2;
56513   {
56514     try {
56515       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56516     } catch (std::out_of_range& e) {
56517       {
56518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56519       };
56520     } catch (std::exception& e) {
56521       {
56522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56523       };
56524     } catch (Dali::DaliException e) {
56525       {
56526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56527       };
56528     } catch (...) {
56529       {
56530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56531       };
56532     }
56533   }
56534
56535 }
56536
56537
56538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
56539   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56540   Dali::TouchData *arg2 = 0 ;
56541
56542   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56543   arg2 = (Dali::TouchData *)jarg2;
56544   if (!arg2) {
56545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
56546     return ;
56547   }
56548   {
56549     try {
56550       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
56551     } catch (std::out_of_range& e) {
56552       {
56553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56554       };
56555     } catch (std::exception& e) {
56556       {
56557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56558       };
56559     } catch (Dali::DaliException e) {
56560       {
56561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56562       };
56563     } catch (...) {
56564       {
56565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56566       };
56567     }
56568   }
56569
56570 }
56571
56572
56573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
56574   void * jresult ;
56575   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
56576
56577   {
56578     try {
56579       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
56580     } catch (std::out_of_range& e) {
56581       {
56582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56583       };
56584     } catch (std::exception& e) {
56585       {
56586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56587       };
56588     } catch (Dali::DaliException e) {
56589       {
56590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56591       };
56592     } catch (...) {
56593       {
56594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56595       };
56596     }
56597   }
56598
56599   jresult = (void *)result;
56600   return jresult;
56601 }
56602
56603
56604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
56605   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
56606
56607   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
56608   {
56609     try {
56610       delete arg1;
56611     } catch (std::out_of_range& e) {
56612       {
56613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56614       };
56615     } catch (std::exception& e) {
56616       {
56617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56618       };
56619     } catch (Dali::DaliException e) {
56620       {
56621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56622       };
56623     } catch (...) {
56624       {
56625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56626       };
56627     }
56628   }
56629
56630 }
56631
56632
56633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
56634   unsigned int jresult ;
56635   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56636   bool result;
56637
56638   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56639   {
56640     try {
56641       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56642     } catch (std::out_of_range& e) {
56643       {
56644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56645       };
56646     } catch (std::exception& e) {
56647       {
56648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56649       };
56650     } catch (Dali::DaliException e) {
56651       {
56652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56653       };
56654     } catch (...) {
56655       {
56656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56657       };
56658     }
56659   }
56660
56661   jresult = result;
56662   return jresult;
56663 }
56664
56665
56666 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
56667   unsigned long jresult ;
56668   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56669   std::size_t result;
56670
56671   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56672   {
56673     try {
56674       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
56675     } catch (std::out_of_range& e) {
56676       {
56677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56678       };
56679     } catch (std::exception& e) {
56680       {
56681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56682       };
56683     } catch (Dali::DaliException e) {
56684       {
56685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56686       };
56687     } catch (...) {
56688       {
56689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56690       };
56691     }
56692   }
56693
56694   jresult = (unsigned long)result;
56695   return jresult;
56696 }
56697
56698
56699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
56700   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56701   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56702
56703   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56704   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56705   {
56706     try {
56707       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56708     } catch (std::out_of_range& e) {
56709       {
56710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56711       };
56712     } catch (std::exception& e) {
56713       {
56714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56715       };
56716     } catch (Dali::DaliException e) {
56717       {
56718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56719       };
56720     } catch (...) {
56721       {
56722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56723       };
56724     }
56725   }
56726
56727 }
56728
56729
56730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
56731   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56732   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
56733
56734   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56735   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
56736   {
56737     try {
56738       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56739     } catch (std::out_of_range& e) {
56740       {
56741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56742       };
56743     } catch (std::exception& e) {
56744       {
56745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56746       };
56747     } catch (Dali::DaliException e) {
56748       {
56749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56750       };
56751     } catch (...) {
56752       {
56753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56754       };
56755     }
56756   }
56757
56758 }
56759
56760
56761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
56762   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56763   Dali::WheelEvent *arg2 = 0 ;
56764
56765   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56766   arg2 = (Dali::WheelEvent *)jarg2;
56767   if (!arg2) {
56768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
56769     return ;
56770   }
56771   {
56772     try {
56773       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
56774     } catch (std::out_of_range& e) {
56775       {
56776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56777       };
56778     } catch (std::exception& e) {
56779       {
56780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56781       };
56782     } catch (Dali::DaliException e) {
56783       {
56784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56785       };
56786     } catch (...) {
56787       {
56788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56789       };
56790     }
56791   }
56792
56793 }
56794
56795
56796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
56797   void * jresult ;
56798   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
56799
56800   {
56801     try {
56802       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
56803     } catch (std::out_of_range& e) {
56804       {
56805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56806       };
56807     } catch (std::exception& e) {
56808       {
56809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56810       };
56811     } catch (Dali::DaliException e) {
56812       {
56813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56814       };
56815     } catch (...) {
56816       {
56817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56818       };
56819     }
56820   }
56821
56822   jresult = (void *)result;
56823   return jresult;
56824 }
56825
56826
56827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
56828   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
56829
56830   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
56831   {
56832     try {
56833       delete arg1;
56834     } catch (std::out_of_range& e) {
56835       {
56836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56837       };
56838     } catch (std::exception& e) {
56839       {
56840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56841       };
56842     } catch (Dali::DaliException e) {
56843       {
56844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56845       };
56846     } catch (...) {
56847       {
56848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56849       };
56850     }
56851   }
56852
56853 }
56854
56855
56856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
56857   void * jresult ;
56858   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56859
56860   {
56861     try {
56862       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
56863     } catch (std::out_of_range& e) {
56864       {
56865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56866       };
56867     } catch (std::exception& e) {
56868       {
56869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56870       };
56871     } catch (Dali::DaliException e) {
56872       {
56873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56874       };
56875     } catch (...) {
56876       {
56877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56878       };
56879     }
56880   }
56881
56882   jresult = (void *)result;
56883   return jresult;
56884 }
56885
56886
56887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
56888   void * jresult ;
56889   Dali::Radian arg1 ;
56890   Dali::Radian arg2 ;
56891   Dali::Radian *argp1 ;
56892   Dali::Radian *argp2 ;
56893   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56894
56895   argp1 = (Dali::Radian *)jarg1;
56896   if (!argp1) {
56897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56898     return 0;
56899   }
56900   arg1 = *argp1;
56901   argp2 = (Dali::Radian *)jarg2;
56902   if (!argp2) {
56903     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
56904     return 0;
56905   }
56906   arg2 = *argp2;
56907   {
56908     try {
56909       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
56910     } catch (std::out_of_range& e) {
56911       {
56912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56913       };
56914     } catch (std::exception& e) {
56915       {
56916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56917       };
56918     } catch (Dali::DaliException e) {
56919       {
56920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56921       };
56922     } catch (...) {
56923       {
56924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56925       };
56926     }
56927   }
56928
56929   jresult = (void *)result;
56930   return jresult;
56931 }
56932
56933
56934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
56935   void * jresult ;
56936   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
56937   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
56938
56939   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56940   if (!arg1) {
56941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
56942     return 0;
56943   }
56944   {
56945     try {
56946       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
56947     } catch (std::out_of_range& e) {
56948       {
56949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56950       };
56951     } catch (std::exception& e) {
56952       {
56953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56954       };
56955     } catch (Dali::DaliException e) {
56956       {
56957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56958       };
56959     } catch (...) {
56960       {
56961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56962       };
56963     }
56964   }
56965
56966   jresult = (void *)result;
56967   return jresult;
56968 }
56969
56970
56971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
56972   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56973   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56974
56975   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56976   arg2 = (Dali::Radian *)jarg2;
56977   if (arg1) (arg1)->first = *arg2;
56978 }
56979
56980
56981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
56982   void * jresult ;
56983   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56984   Dali::Radian *result = 0 ;
56985
56986   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56987   result = (Dali::Radian *)& ((arg1)->first);
56988   jresult = (void *)result;
56989   return jresult;
56990 }
56991
56992
56993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
56994   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
56995   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
56996
56997   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
56998   arg2 = (Dali::Radian *)jarg2;
56999   if (arg1) (arg1)->second = *arg2;
57000 }
57001
57002
57003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
57004   void * jresult ;
57005   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57006   Dali::Radian *result = 0 ;
57007
57008   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57009   result = (Dali::Radian *)& ((arg1)->second);
57010   jresult = (void *)result;
57011   return jresult;
57012 }
57013
57014
57015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
57016   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
57017
57018   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
57019   {
57020     try {
57021       delete arg1;
57022     } catch (std::out_of_range& e) {
57023       {
57024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57025       };
57026     } catch (std::exception& e) {
57027       {
57028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57029       };
57030     } catch (Dali::DaliException e) {
57031       {
57032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57033       };
57034     } catch (...) {
57035       {
57036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57037       };
57038     }
57039   }
57040
57041 }
57042
57043
57044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
57045   unsigned int jresult ;
57046   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57047   bool result;
57048
57049   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57050   {
57051     try {
57052       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);
57053     } catch (std::out_of_range& e) {
57054       {
57055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57056       };
57057     } catch (std::exception& e) {
57058       {
57059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57060       };
57061     } catch (Dali::DaliException e) {
57062       {
57063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57064       };
57065     } catch (...) {
57066       {
57067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57068       };
57069     }
57070   }
57071
57072   jresult = result;
57073   return jresult;
57074 }
57075
57076
57077 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57078   unsigned long jresult ;
57079   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57080   std::size_t result;
57081
57082   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57083   {
57084     try {
57085       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);
57086     } catch (std::out_of_range& e) {
57087       {
57088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57089       };
57090     } catch (std::exception& e) {
57091       {
57092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57093       };
57094     } catch (Dali::DaliException e) {
57095       {
57096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57097       };
57098     } catch (...) {
57099       {
57100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57101       };
57102     }
57103   }
57104
57105   jresult = (unsigned long)result;
57106   return jresult;
57107 }
57108
57109
57110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57111   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57112   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57113
57114   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57115   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57116   {
57117     try {
57118       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57119     } catch (std::out_of_range& e) {
57120       {
57121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57122       };
57123     } catch (std::exception& e) {
57124       {
57125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57126       };
57127     } catch (Dali::DaliException e) {
57128       {
57129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57130       };
57131     } catch (...) {
57132       {
57133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57134       };
57135     }
57136   }
57137
57138 }
57139
57140
57141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57142   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57143   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
57144
57145   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57146   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
57147   {
57148     try {
57149       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57150     } catch (std::out_of_range& e) {
57151       {
57152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57153       };
57154     } catch (std::exception& e) {
57155       {
57156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57157       };
57158     } catch (Dali::DaliException e) {
57159       {
57160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57161       };
57162     } catch (...) {
57163       {
57164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57165       };
57166     }
57167   }
57168
57169 }
57170
57171
57172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57173   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57174   Dali::Actor arg2 ;
57175   Dali::PanGesture *arg3 = 0 ;
57176   Dali::Actor *argp2 ;
57177
57178   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57179   argp2 = (Dali::Actor *)jarg2;
57180   if (!argp2) {
57181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57182     return ;
57183   }
57184   arg2 = *argp2;
57185   arg3 = (Dali::PanGesture *)jarg3;
57186   if (!arg3) {
57187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
57188     return ;
57189   }
57190   {
57191     try {
57192       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
57193     } catch (std::out_of_range& e) {
57194       {
57195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57196       };
57197     } catch (std::exception& e) {
57198       {
57199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57200       };
57201     } catch (Dali::DaliException e) {
57202       {
57203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57204       };
57205     } catch (...) {
57206       {
57207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57208       };
57209     }
57210   }
57211
57212 }
57213
57214
57215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
57216   void * jresult ;
57217   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
57218
57219   {
57220     try {
57221       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
57222     } catch (std::out_of_range& e) {
57223       {
57224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57225       };
57226     } catch (std::exception& e) {
57227       {
57228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57229       };
57230     } catch (Dali::DaliException e) {
57231       {
57232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57233       };
57234     } catch (...) {
57235       {
57236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57237       };
57238     }
57239   }
57240
57241   jresult = (void *)result;
57242   return jresult;
57243 }
57244
57245
57246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
57247   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
57248
57249   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
57250   {
57251     try {
57252       delete arg1;
57253     } catch (std::out_of_range& e) {
57254       {
57255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57256       };
57257     } catch (std::exception& e) {
57258       {
57259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57260       };
57261     } catch (Dali::DaliException e) {
57262       {
57263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57264       };
57265     } catch (...) {
57266       {
57267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57268       };
57269     }
57270   }
57271
57272 }
57273
57274
57275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
57276   unsigned int jresult ;
57277   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57278   bool result;
57279
57280   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57281   {
57282     try {
57283       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);
57284     } catch (std::out_of_range& e) {
57285       {
57286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57287       };
57288     } catch (std::exception& e) {
57289       {
57290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57291       };
57292     } catch (Dali::DaliException e) {
57293       {
57294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57295       };
57296     } catch (...) {
57297       {
57298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57299       };
57300     }
57301   }
57302
57303   jresult = result;
57304   return jresult;
57305 }
57306
57307
57308 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57309   unsigned long jresult ;
57310   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57311   std::size_t result;
57312
57313   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57314   {
57315     try {
57316       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);
57317     } catch (std::out_of_range& e) {
57318       {
57319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57320       };
57321     } catch (std::exception& e) {
57322       {
57323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57324       };
57325     } catch (Dali::DaliException e) {
57326       {
57327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57328       };
57329     } catch (...) {
57330       {
57331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57332       };
57333     }
57334   }
57335
57336   jresult = (unsigned long)result;
57337   return jresult;
57338 }
57339
57340
57341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57342   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57343   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57344
57345   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57346   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57347   {
57348     try {
57349       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57350     } catch (std::out_of_range& e) {
57351       {
57352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57353       };
57354     } catch (std::exception& e) {
57355       {
57356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57357       };
57358     } catch (Dali::DaliException e) {
57359       {
57360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57361       };
57362     } catch (...) {
57363       {
57364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57365       };
57366     }
57367   }
57368
57369 }
57370
57371
57372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57373   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57374   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
57375
57376   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57377   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
57378   {
57379     try {
57380       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57381     } catch (std::out_of_range& e) {
57382       {
57383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57384       };
57385     } catch (std::exception& e) {
57386       {
57387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57388       };
57389     } catch (Dali::DaliException e) {
57390       {
57391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57392       };
57393     } catch (...) {
57394       {
57395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57396       };
57397     }
57398   }
57399
57400 }
57401
57402
57403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57404   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57405   Dali::Actor arg2 ;
57406   Dali::PinchGesture *arg3 = 0 ;
57407   Dali::Actor *argp2 ;
57408
57409   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57410   argp2 = (Dali::Actor *)jarg2;
57411   if (!argp2) {
57412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57413     return ;
57414   }
57415   arg2 = *argp2;
57416   arg3 = (Dali::PinchGesture *)jarg3;
57417   if (!arg3) {
57418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
57419     return ;
57420   }
57421   {
57422     try {
57423       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
57424     } catch (std::out_of_range& e) {
57425       {
57426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57427       };
57428     } catch (std::exception& e) {
57429       {
57430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57431       };
57432     } catch (Dali::DaliException e) {
57433       {
57434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57435       };
57436     } catch (...) {
57437       {
57438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57439       };
57440     }
57441   }
57442
57443 }
57444
57445
57446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
57447   void * jresult ;
57448   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
57449
57450   {
57451     try {
57452       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
57453     } catch (std::out_of_range& e) {
57454       {
57455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57456       };
57457     } catch (std::exception& e) {
57458       {
57459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57460       };
57461     } catch (Dali::DaliException e) {
57462       {
57463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57464       };
57465     } catch (...) {
57466       {
57467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57468       };
57469     }
57470   }
57471
57472   jresult = (void *)result;
57473   return jresult;
57474 }
57475
57476
57477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
57478   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
57479
57480   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
57481   {
57482     try {
57483       delete arg1;
57484     } catch (std::out_of_range& e) {
57485       {
57486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57487       };
57488     } catch (std::exception& e) {
57489       {
57490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57491       };
57492     } catch (Dali::DaliException e) {
57493       {
57494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57495       };
57496     } catch (...) {
57497       {
57498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57499       };
57500     }
57501   }
57502
57503 }
57504
57505
57506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
57507   unsigned int jresult ;
57508   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57509   bool result;
57510
57511   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57512   {
57513     try {
57514       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);
57515     } catch (std::out_of_range& e) {
57516       {
57517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57518       };
57519     } catch (std::exception& e) {
57520       {
57521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57522       };
57523     } catch (Dali::DaliException e) {
57524       {
57525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57526       };
57527     } catch (...) {
57528       {
57529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57530       };
57531     }
57532   }
57533
57534   jresult = result;
57535   return jresult;
57536 }
57537
57538
57539 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
57540   unsigned long jresult ;
57541   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57542   std::size_t result;
57543
57544   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57545   {
57546     try {
57547       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);
57548     } catch (std::out_of_range& e) {
57549       {
57550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57551       };
57552     } catch (std::exception& e) {
57553       {
57554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57555       };
57556     } catch (Dali::DaliException e) {
57557       {
57558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57559       };
57560     } catch (...) {
57561       {
57562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57563       };
57564     }
57565   }
57566
57567   jresult = (unsigned long)result;
57568   return jresult;
57569 }
57570
57571
57572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
57573   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57574   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57575
57576   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57577   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57578   {
57579     try {
57580       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
57581     } catch (std::out_of_range& e) {
57582       {
57583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57584       };
57585     } catch (std::exception& e) {
57586       {
57587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57588       };
57589     } catch (Dali::DaliException e) {
57590       {
57591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57592       };
57593     } catch (...) {
57594       {
57595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57596       };
57597     }
57598   }
57599
57600 }
57601
57602
57603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
57604   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57605   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
57606
57607   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57608   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
57609   {
57610     try {
57611       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
57612     } catch (std::out_of_range& e) {
57613       {
57614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57615       };
57616     } catch (std::exception& e) {
57617       {
57618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57619       };
57620     } catch (Dali::DaliException e) {
57621       {
57622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57623       };
57624     } catch (...) {
57625       {
57626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57627       };
57628     }
57629   }
57630
57631 }
57632
57633
57634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
57635   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57636   Dali::Actor arg2 ;
57637   Dali::TapGesture *arg3 = 0 ;
57638   Dali::Actor *argp2 ;
57639
57640   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57641   argp2 = (Dali::Actor *)jarg2;
57642   if (!argp2) {
57643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57644     return ;
57645   }
57646   arg2 = *argp2;
57647   arg3 = (Dali::TapGesture *)jarg3;
57648   if (!arg3) {
57649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
57650     return ;
57651   }
57652   {
57653     try {
57654       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
57655     } catch (std::out_of_range& e) {
57656       {
57657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57658       };
57659     } catch (std::exception& e) {
57660       {
57661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57662       };
57663     } catch (Dali::DaliException e) {
57664       {
57665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57666       };
57667     } catch (...) {
57668       {
57669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57670       };
57671     }
57672   }
57673
57674 }
57675
57676
57677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
57678   void * jresult ;
57679   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
57680
57681   {
57682     try {
57683       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
57684     } catch (std::out_of_range& e) {
57685       {
57686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57687       };
57688     } catch (std::exception& e) {
57689       {
57690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57691       };
57692     } catch (Dali::DaliException e) {
57693       {
57694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57695       };
57696     } catch (...) {
57697       {
57698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57699       };
57700     }
57701   }
57702
57703   jresult = (void *)result;
57704   return jresult;
57705 }
57706
57707
57708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
57709   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
57710
57711   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
57712   {
57713     try {
57714       delete arg1;
57715     } catch (std::out_of_range& e) {
57716       {
57717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57718       };
57719     } catch (std::exception& e) {
57720       {
57721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57722       };
57723     } catch (Dali::DaliException e) {
57724       {
57725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57726       };
57727     } catch (...) {
57728       {
57729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57730       };
57731     }
57732   }
57733
57734 }
57735
57736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
57737   unsigned int jresult ;
57738   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57739   bool result;
57740
57741   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57742   {
57743     try {
57744       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57745     } catch (std::out_of_range& e) {
57746       {
57747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57748       };
57749     } catch (std::exception& e) {
57750       {
57751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57752       };
57753     } catch (Dali::DaliException e) {
57754       {
57755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57756       };
57757     } catch (...) {
57758       {
57759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57760       };
57761     }
57762   }
57763
57764   jresult = result;
57765   return jresult;
57766 }
57767
57768
57769 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
57770   unsigned long jresult ;
57771   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57772   std::size_t result;
57773
57774   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57775   {
57776     try {
57777       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
57778     } catch (std::out_of_range& e) {
57779       {
57780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57781       };
57782     } catch (std::exception& e) {
57783       {
57784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57785       };
57786     } catch (Dali::DaliException e) {
57787       {
57788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57789       };
57790     } catch (...) {
57791       {
57792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57793       };
57794     }
57795   }
57796
57797   jresult = (unsigned long)result;
57798   return jresult;
57799 }
57800
57801
57802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
57803   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57804   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57805
57806   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57807   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57808   {
57809     try {
57810       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
57811     } catch (std::out_of_range& e) {
57812       {
57813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57814       };
57815     } catch (std::exception& e) {
57816       {
57817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57818       };
57819     } catch (Dali::DaliException e) {
57820       {
57821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57822       };
57823     } catch (...) {
57824       {
57825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57826       };
57827     }
57828   }
57829
57830 }
57831
57832
57833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
57834   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57835   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
57836
57837   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57838   arg2 = (void (*)(Dali::ResourceImage))jarg2;
57839   {
57840     try {
57841       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
57842     } catch (std::out_of_range& e) {
57843       {
57844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57845       };
57846     } catch (std::exception& e) {
57847       {
57848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57849       };
57850     } catch (Dali::DaliException e) {
57851       {
57852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57853       };
57854     } catch (...) {
57855       {
57856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57857       };
57858     }
57859   }
57860
57861 }
57862
57863
57864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
57865   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57866   Dali::ResourceImage arg2 ;
57867   Dali::ResourceImage *argp2 ;
57868
57869   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57870   argp2 = (Dali::ResourceImage *)jarg2;
57871   if (!argp2) {
57872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
57873     return ;
57874   }
57875   arg2 = *argp2;
57876   {
57877     try {
57878       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
57879     } catch (std::out_of_range& e) {
57880       {
57881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57882       };
57883     } catch (std::exception& e) {
57884       {
57885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57886       };
57887     } catch (Dali::DaliException e) {
57888       {
57889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57890       };
57891     } catch (...) {
57892       {
57893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57894       };
57895     }
57896   }
57897
57898 }
57899
57900
57901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
57902   void * jresult ;
57903   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
57904
57905   {
57906     try {
57907       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
57908     } catch (std::out_of_range& e) {
57909       {
57910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57911       };
57912     } catch (std::exception& e) {
57913       {
57914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57915       };
57916     } catch (Dali::DaliException e) {
57917       {
57918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57919       };
57920     } catch (...) {
57921       {
57922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57923       };
57924     }
57925   }
57926
57927   jresult = (void *)result;
57928   return jresult;
57929 }
57930
57931
57932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
57933   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
57934
57935   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
57936   {
57937     try {
57938       delete arg1;
57939     } catch (std::out_of_range& e) {
57940       {
57941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57942       };
57943     } catch (std::exception& e) {
57944       {
57945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57946       };
57947     } catch (Dali::DaliException e) {
57948       {
57949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57950       };
57951     } catch (...) {
57952       {
57953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57954       };
57955     }
57956   }
57957
57958 }
57959
57960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
57961   unsigned int jresult ;
57962   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57963   bool result = false;
57964
57965   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57966   {
57967     try {
57968       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);
57969     } catch (std::out_of_range& e) {
57970       {
57971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57972       };
57973     } catch (std::exception& e) {
57974       {
57975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57976       };
57977     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
57978   }
57979   jresult = result;
57980   return jresult;
57981 }
57982
57983 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
57984   unsigned long jresult ;
57985   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
57986   std::size_t result = 0;
57987
57988   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
57989   {
57990     try {
57991       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);
57992     } catch (std::out_of_range& e) {
57993       {
57994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57995       };
57996     } catch (std::exception& e) {
57997       {
57998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57999       };
58000     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58001   }
58002   jresult = (unsigned long)result;
58003   return jresult;
58004 }
58005
58006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
58007   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58008   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58009
58010   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58011   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58012   {
58013     try {
58014       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
58015     } catch (std::out_of_range& e) {
58016       {
58017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58018       };
58019     } catch (std::exception& e) {
58020       {
58021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58022       };
58023     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58024   }
58025 }
58026
58027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
58028   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58029   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
58030
58031   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58032   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
58033   {
58034     try {
58035       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
58036     } catch (std::out_of_range& e) {
58037       {
58038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58039       };
58040     } catch (std::exception& e) {
58041       {
58042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58043       };
58044     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58045   }
58046 }
58047
58048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
58049   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58050   Dali::Actor arg2 ;
58051   //bool arg3 ;
58052   Dali::LayoutDirection::Type arg4 ;
58053   Dali::Actor *argp2 ;
58054
58055   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58056   argp2 = (Dali::Actor *)jarg2;
58057   if (!argp2) {
58058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58059     return ;
58060   }
58061   arg2 = *argp2;
58062   //arg3 = jarg3 ? true : false;
58063   arg4 = (Dali::LayoutDirection::Type)jarg4;
58064   {
58065     try {
58066       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
58067     } catch (std::out_of_range& e) {
58068       {
58069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58070       };
58071     } catch (std::exception& e) {
58072       {
58073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58074       };
58075     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58076   }
58077 }
58078
58079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
58080   void * jresult ;
58081   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
58082
58083   {
58084     try {
58085       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
58086     } catch (std::out_of_range& e) {
58087       {
58088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58089       };
58090     } catch (std::exception& e) {
58091       {
58092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58093       };
58094     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58095   }
58096   jresult = (void *)result;
58097   return jresult;
58098 }
58099
58100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
58101   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
58102
58103   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
58104   {
58105     try {
58106       delete arg1;
58107     } catch (std::out_of_range& e) {
58108       {
58109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58110       };
58111     } catch (std::exception& e) {
58112       {
58113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58114       };
58115     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
58116   }
58117 }
58118
58119 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
58120   unsigned int jresult ;
58121   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58122   bool result;
58123
58124   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58125   {
58126     try {
58127       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);
58128     } catch (std::out_of_range& e) {
58129       {
58130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58131       };
58132     } catch (std::exception& e) {
58133       {
58134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58135       };
58136     } catch (Dali::DaliException e) {
58137       {
58138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58139       };
58140     } catch (...) {
58141       {
58142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58143       };
58144     }
58145   }
58146
58147   jresult = result;
58148   return jresult;
58149 }
58150
58151
58152 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
58153   unsigned long jresult ;
58154   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58155   std::size_t result;
58156
58157   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58158   {
58159     try {
58160       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);
58161     } catch (std::out_of_range& e) {
58162       {
58163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58164       };
58165     } catch (std::exception& e) {
58166       {
58167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58168       };
58169     } catch (Dali::DaliException e) {
58170       {
58171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58172       };
58173     } catch (...) {
58174       {
58175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58176       };
58177     }
58178   }
58179
58180   jresult = (unsigned long)result;
58181   return jresult;
58182 }
58183
58184
58185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
58186   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58187   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58188
58189   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58190   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58191   {
58192     try {
58193       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
58194     } catch (std::out_of_range& e) {
58195       {
58196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58197       };
58198     } catch (std::exception& e) {
58199       {
58200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58201       };
58202     } catch (Dali::DaliException e) {
58203       {
58204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58205       };
58206     } catch (...) {
58207       {
58208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58209       };
58210     }
58211   }
58212
58213 }
58214
58215
58216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
58217   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58218   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
58219
58220   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58221   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
58222   {
58223     try {
58224       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
58225     } catch (std::out_of_range& e) {
58226       {
58227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58228       };
58229     } catch (std::exception& e) {
58230       {
58231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58232       };
58233     } catch (Dali::DaliException e) {
58234       {
58235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58236       };
58237     } catch (...) {
58238       {
58239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58240       };
58241     }
58242   }
58243
58244 }
58245
58246
58247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
58248   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58249   Dali::Actor arg2 ;
58250   bool arg3 ;
58251   Dali::DevelActor::VisibilityChange::Type arg4 ;
58252   Dali::Actor *argp2 ;
58253
58254   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58255   argp2 = (Dali::Actor *)jarg2;
58256   if (!argp2) {
58257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58258     return ;
58259   }
58260   arg2 = *argp2;
58261   arg3 = jarg3 ? true : false;
58262   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
58263   {
58264     try {
58265       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
58266     } catch (std::out_of_range& e) {
58267       {
58268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58269       };
58270     } catch (std::exception& e) {
58271       {
58272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58273       };
58274     } catch (Dali::DaliException e) {
58275       {
58276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58277       };
58278     } catch (...) {
58279       {
58280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58281       };
58282     }
58283   }
58284
58285 }
58286
58287
58288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
58289   void * jresult ;
58290   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
58291
58292   {
58293     try {
58294       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
58295     } catch (std::out_of_range& e) {
58296       {
58297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58298       };
58299     } catch (std::exception& e) {
58300       {
58301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58302       };
58303     } catch (Dali::DaliException e) {
58304       {
58305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58306       };
58307     } catch (...) {
58308       {
58309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58310       };
58311     }
58312   }
58313
58314   jresult = (void *)result;
58315   return jresult;
58316 }
58317
58318
58319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
58320   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
58321
58322   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
58323   {
58324     try {
58325       delete arg1;
58326     } catch (std::out_of_range& e) {
58327       {
58328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58329       };
58330     } catch (std::exception& e) {
58331       {
58332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58333       };
58334     } catch (Dali::DaliException e) {
58335       {
58336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58337       };
58338     } catch (...) {
58339       {
58340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58341       };
58342     }
58343   }
58344
58345 }
58346
58347
58348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
58349   void * jresult ;
58350   Dali::Timer *result = 0 ;
58351
58352   {
58353     try {
58354       result = (Dali::Timer *)new Dali::Timer();
58355     } catch (std::out_of_range& e) {
58356       {
58357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58358       };
58359     } catch (std::exception& e) {
58360       {
58361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58362       };
58363     } catch (Dali::DaliException e) {
58364       {
58365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58366       };
58367     } catch (...) {
58368       {
58369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58370       };
58371     }
58372   }
58373
58374   jresult = (void *)result;
58375   return jresult;
58376 }
58377
58378
58379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
58380   void * jresult ;
58381   unsigned int arg1 ;
58382   Dali::Timer result;
58383
58384   arg1 = (unsigned int)jarg1;
58385   {
58386     try {
58387       result = Dali::Timer::New(arg1);
58388     } catch (std::out_of_range& e) {
58389       {
58390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58391       };
58392     } catch (std::exception& e) {
58393       {
58394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58395       };
58396     } catch (Dali::DaliException e) {
58397       {
58398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58399       };
58400     } catch (...) {
58401       {
58402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58403       };
58404     }
58405   }
58406
58407   jresult = new Dali::Timer((const Dali::Timer &)result);
58408   return jresult;
58409 }
58410
58411
58412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
58413   void * jresult ;
58414   Dali::Timer *arg1 = 0 ;
58415   Dali::Timer *result = 0 ;
58416
58417   arg1 = (Dali::Timer *)jarg1;
58418   if (!arg1) {
58419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58420     return 0;
58421   }
58422   {
58423     try {
58424       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
58425     } catch (std::out_of_range& e) {
58426       {
58427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58428       };
58429     } catch (std::exception& e) {
58430       {
58431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58432       };
58433     } catch (Dali::DaliException e) {
58434       {
58435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58436       };
58437     } catch (...) {
58438       {
58439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58440       };
58441     }
58442   }
58443
58444   jresult = (void *)result;
58445   return jresult;
58446 }
58447
58448
58449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
58450   void * jresult ;
58451   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58452   Dali::Timer *arg2 = 0 ;
58453   Dali::Timer *result = 0 ;
58454
58455   arg1 = (Dali::Timer *)jarg1;
58456   arg2 = (Dali::Timer *)jarg2;
58457   if (!arg2) {
58458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
58459     return 0;
58460   }
58461   {
58462     try {
58463       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
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_delete_Timer(void * jarg1) {
58489   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58490
58491   arg1 = (Dali::Timer *)jarg1;
58492   {
58493     try {
58494       delete arg1;
58495     } catch (std::out_of_range& e) {
58496       {
58497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58498       };
58499     } catch (std::exception& e) {
58500       {
58501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58502       };
58503     } catch (Dali::DaliException e) {
58504       {
58505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58506       };
58507     } catch (...) {
58508       {
58509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58510       };
58511     }
58512   }
58513
58514 }
58515
58516
58517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
58518   void * jresult ;
58519   Dali::BaseHandle arg1 ;
58520   Dali::BaseHandle *argp1 ;
58521   Dali::Timer result;
58522
58523   argp1 = (Dali::BaseHandle *)jarg1;
58524   if (!argp1) {
58525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58526     return 0;
58527   }
58528   arg1 = *argp1;
58529   {
58530     try {
58531       result = Dali::Timer::DownCast(arg1);
58532     } catch (std::out_of_range& e) {
58533       {
58534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58535       };
58536     } catch (std::exception& e) {
58537       {
58538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58539       };
58540     } catch (Dali::DaliException e) {
58541       {
58542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58543       };
58544     } catch (...) {
58545       {
58546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58547       };
58548     }
58549   }
58550
58551   jresult = new Dali::Timer((const Dali::Timer &)result);
58552   return jresult;
58553 }
58554
58555
58556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
58557   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58558
58559   arg1 = (Dali::Timer *)jarg1;
58560   {
58561     try {
58562       (arg1)->Start();
58563     } catch (std::out_of_range& e) {
58564       {
58565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58566       };
58567     } catch (std::exception& e) {
58568       {
58569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58570       };
58571     } catch (Dali::DaliException e) {
58572       {
58573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58574       };
58575     } catch (...) {
58576       {
58577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58578       };
58579     }
58580   }
58581
58582 }
58583
58584
58585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
58586   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58587
58588   arg1 = (Dali::Timer *)jarg1;
58589   {
58590     try {
58591       (arg1)->Stop();
58592     } catch (std::out_of_range& e) {
58593       {
58594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58595       };
58596     } catch (std::exception& e) {
58597       {
58598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58599       };
58600     } catch (Dali::DaliException e) {
58601       {
58602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58603       };
58604     } catch (...) {
58605       {
58606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58607       };
58608     }
58609   }
58610
58611 }
58612
58613
58614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
58615   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58616   unsigned int arg2 ;
58617
58618   arg1 = (Dali::Timer *)jarg1;
58619   arg2 = (unsigned int)jarg2;
58620   {
58621     try {
58622       (arg1)->SetInterval(arg2);
58623     } catch (std::out_of_range& e) {
58624       {
58625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58626       };
58627     } catch (std::exception& e) {
58628       {
58629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58630       };
58631     } catch (Dali::DaliException e) {
58632       {
58633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58634       };
58635     } catch (...) {
58636       {
58637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58638       };
58639     }
58640   }
58641
58642 }
58643
58644
58645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
58646   unsigned int jresult ;
58647   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58648   unsigned int result;
58649
58650   arg1 = (Dali::Timer *)jarg1;
58651   {
58652     try {
58653       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
58654     } catch (std::out_of_range& e) {
58655       {
58656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58657       };
58658     } catch (std::exception& e) {
58659       {
58660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58661       };
58662     } catch (Dali::DaliException e) {
58663       {
58664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58665       };
58666     } catch (...) {
58667       {
58668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58669       };
58670     }
58671   }
58672
58673   jresult = result;
58674   return jresult;
58675 }
58676
58677
58678 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
58679   unsigned int jresult ;
58680   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58681   bool result;
58682
58683   arg1 = (Dali::Timer *)jarg1;
58684   {
58685     try {
58686       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
58687     } catch (std::out_of_range& e) {
58688       {
58689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58690       };
58691     } catch (std::exception& e) {
58692       {
58693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58694       };
58695     } catch (Dali::DaliException e) {
58696       {
58697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58698       };
58699     } catch (...) {
58700       {
58701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58702       };
58703     }
58704   }
58705
58706   jresult = result;
58707   return jresult;
58708 }
58709
58710
58711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
58712   void * jresult ;
58713   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
58714   Dali::Timer::TimerSignalType *result = 0 ;
58715
58716   arg1 = (Dali::Timer *)jarg1;
58717   {
58718     try {
58719       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
58720     } catch (std::out_of_range& e) {
58721       {
58722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58723       };
58724     } catch (std::exception& e) {
58725       {
58726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58727       };
58728     } catch (Dali::DaliException e) {
58729       {
58730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58731       };
58732     } catch (...) {
58733       {
58734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58735       };
58736     }
58737   }
58738
58739   jresult = (void *)result;
58740   return jresult;
58741 }
58742
58743
58744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
58745   unsigned int jresult ;
58746   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58747   bool result;
58748
58749   arg1 = (Dali::Signal< bool () > *)jarg1;
58750   {
58751     try {
58752       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
58753     } catch (std::out_of_range& e) {
58754       {
58755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58756       };
58757     } catch (std::exception& e) {
58758       {
58759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58760       };
58761     } catch (Dali::DaliException e) {
58762       {
58763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58764       };
58765     } catch (...) {
58766       {
58767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58768       };
58769     }
58770   }
58771
58772   jresult = result;
58773   return jresult;
58774 }
58775
58776
58777 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
58778   unsigned long jresult ;
58779   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58780   std::size_t result;
58781
58782   arg1 = (Dali::Signal< bool () > *)jarg1;
58783   {
58784     try {
58785       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
58786     } catch (std::out_of_range& e) {
58787       {
58788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58789       };
58790     } catch (std::exception& e) {
58791       {
58792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58793       };
58794     } catch (Dali::DaliException e) {
58795       {
58796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58797       };
58798     } catch (...) {
58799       {
58800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58801       };
58802     }
58803   }
58804
58805   jresult = (unsigned long)result;
58806   return jresult;
58807 }
58808
58809
58810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
58811   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58812   bool (*arg2)() = (bool (*)()) 0 ;
58813
58814   arg1 = (Dali::Signal< bool () > *)jarg1;
58815   arg2 = (bool (*)())jarg2;
58816   {
58817     try {
58818       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
58819     } catch (std::out_of_range& e) {
58820       {
58821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58822       };
58823     } catch (std::exception& e) {
58824       {
58825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58826       };
58827     } catch (Dali::DaliException e) {
58828       {
58829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58830       };
58831     } catch (...) {
58832       {
58833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58834       };
58835     }
58836   }
58837
58838 }
58839
58840
58841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
58842   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58843   bool (*arg2)() = (bool (*)()) 0 ;
58844
58845   arg1 = (Dali::Signal< bool () > *)jarg1;
58846   arg2 = (bool (*)())jarg2;
58847   {
58848     try {
58849       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
58850     } catch (std::out_of_range& e) {
58851       {
58852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58853       };
58854     } catch (std::exception& e) {
58855       {
58856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58857       };
58858     } catch (Dali::DaliException e) {
58859       {
58860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58861       };
58862     } catch (...) {
58863       {
58864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58865       };
58866     }
58867   }
58868
58869 }
58870
58871
58872 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
58873   unsigned int jresult ;
58874   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58875   bool result;
58876
58877   arg1 = (Dali::Signal< bool () > *)jarg1;
58878   {
58879     try {
58880       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
58881     } catch (std::out_of_range& e) {
58882       {
58883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58884       };
58885     } catch (std::exception& e) {
58886       {
58887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58888       };
58889     } catch (Dali::DaliException e) {
58890       {
58891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58892       };
58893     } catch (...) {
58894       {
58895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58896       };
58897     }
58898   }
58899
58900   jresult = result;
58901   return jresult;
58902 }
58903
58904
58905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
58906   void * jresult ;
58907   Dali::Signal< bool () > *result = 0 ;
58908
58909   {
58910     try {
58911       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
58912     } catch (std::out_of_range& e) {
58913       {
58914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58915       };
58916     } catch (std::exception& e) {
58917       {
58918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58919       };
58920     } catch (Dali::DaliException e) {
58921       {
58922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58923       };
58924     } catch (...) {
58925       {
58926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58927       };
58928     }
58929   }
58930
58931   jresult = (void *)result;
58932   return jresult;
58933 }
58934
58935
58936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
58937   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
58938
58939   arg1 = (Dali::Signal< bool () > *)jarg1;
58940   {
58941     try {
58942       delete arg1;
58943     } catch (std::out_of_range& e) {
58944       {
58945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58946       };
58947     } catch (std::exception& e) {
58948       {
58949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58950       };
58951     } catch (Dali::DaliException e) {
58952       {
58953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58954       };
58955     } catch (...) {
58956       {
58957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58958       };
58959     }
58960   }
58961
58962 }
58963
58964
58965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
58966   int jresult ;
58967   int result;
58968
58969   {
58970     try {
58971       result = (int)Dali::Toolkit::Visual::Property::TYPE;
58972     } catch (std::out_of_range& e) {
58973       {
58974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58975       };
58976     } catch (std::exception& e) {
58977       {
58978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58979       };
58980     } catch (Dali::DaliException e) {
58981       {
58982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58983       };
58984     } catch (...) {
58985       {
58986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58987       };
58988     }
58989   }
58990
58991   jresult = (int)result;
58992   return jresult;
58993 }
58994
58995
58996 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
58997   int jresult ;
58998   int result;
58999
59000   {
59001     try {
59002       result = (int)Dali::Toolkit::Visual::Property::SHADER;
59003     } catch (std::out_of_range& e) {
59004       {
59005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59006       };
59007     } catch (std::exception& e) {
59008       {
59009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59010       };
59011     } catch (Dali::DaliException e) {
59012       {
59013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59014       };
59015     } catch (...) {
59016       {
59017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59018       };
59019     }
59020   }
59021
59022   jresult = (int)result;
59023   return jresult;
59024 }
59025
59026
59027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
59028   int jresult ;
59029   int result;
59030
59031   {
59032     try {
59033       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
59034     } catch (std::out_of_range& e) {
59035       {
59036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59037       };
59038     } catch (std::exception& e) {
59039       {
59040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59041       };
59042     } catch (Dali::DaliException e) {
59043       {
59044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59045       };
59046     } catch (...) {
59047       {
59048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59049       };
59050     }
59051   }
59052
59053   jresult = (int)result;
59054   return jresult;
59055 }
59056
59057
59058 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
59059   int jresult ;
59060   int result;
59061
59062   {
59063     try {
59064       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
59065     } catch (std::out_of_range& e) {
59066       {
59067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59068       };
59069     } catch (std::exception& e) {
59070       {
59071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59072       };
59073     } catch (Dali::DaliException e) {
59074       {
59075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59076       };
59077     } catch (...) {
59078       {
59079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59080       };
59081     }
59082   }
59083
59084   jresult = (int)result;
59085   return jresult;
59086 }
59087
59088
59089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
59090   int jresult ;
59091   int result;
59092
59093   {
59094     try {
59095       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
59096     } catch (std::out_of_range& e) {
59097       {
59098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59099       };
59100     } catch (std::exception& e) {
59101       {
59102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59103       };
59104     } catch (Dali::DaliException e) {
59105       {
59106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59107       };
59108     } catch (...) {
59109       {
59110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59111       };
59112     }
59113   }
59114
59115   jresult = (int)result;
59116   return jresult;
59117 }
59118
59119
59120 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
59121   int jresult ;
59122   int result;
59123
59124   {
59125     try {
59126       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
59127     } catch (std::out_of_range& e) {
59128       {
59129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59130       };
59131     } catch (std::exception& e) {
59132       {
59133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59134       };
59135     } catch (Dali::DaliException e) {
59136       {
59137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59138       };
59139     } catch (...) {
59140       {
59141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59142       };
59143     }
59144   }
59145
59146   jresult = (int)result;
59147   return jresult;
59148 }
59149
59150
59151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
59152   int jresult ;
59153   int result;
59154
59155   {
59156     try {
59157       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
59158     } catch (std::out_of_range& e) {
59159       {
59160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59161       };
59162     } catch (std::exception& e) {
59163       {
59164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59165       };
59166     } catch (Dali::DaliException e) {
59167       {
59168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59169       };
59170     } catch (...) {
59171       {
59172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59173       };
59174     }
59175   }
59176
59177   jresult = (int)result;
59178   return jresult;
59179 }
59180
59181
59182 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
59183   int jresult ;
59184   int result;
59185
59186   {
59187     try {
59188       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
59189     } catch (std::out_of_range& e) {
59190       {
59191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59192       };
59193     } catch (std::exception& e) {
59194       {
59195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59196       };
59197     } catch (Dali::DaliException e) {
59198       {
59199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59200       };
59201     } catch (...) {
59202       {
59203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59204       };
59205     }
59206   }
59207
59208   jresult = (int)result;
59209   return jresult;
59210 }
59211
59212
59213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
59214   int jresult ;
59215   int result;
59216
59217   {
59218     try {
59219       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
59220     } catch (std::out_of_range& e) {
59221       {
59222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59223       };
59224     } catch (std::exception& e) {
59225       {
59226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59227       };
59228     } catch (Dali::DaliException e) {
59229       {
59230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59231       };
59232     } catch (...) {
59233       {
59234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59235       };
59236     }
59237   }
59238
59239   jresult = (int)result;
59240   return jresult;
59241 }
59242
59243
59244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
59245   int jresult ;
59246   int result;
59247
59248   {
59249     try {
59250       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
59251     } catch (std::out_of_range& e) {
59252       {
59253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59254       };
59255     } catch (std::exception& e) {
59256       {
59257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59258       };
59259     } catch (Dali::DaliException e) {
59260       {
59261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59262       };
59263     } catch (...) {
59264       {
59265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59266       };
59267     }
59268   }
59269
59270   jresult = (int)result;
59271   return jresult;
59272 }
59273
59274
59275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
59276   int jresult ;
59277   int result;
59278
59279   {
59280     try {
59281       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
59282     } catch (std::out_of_range& e) {
59283       {
59284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59285       };
59286     } catch (std::exception& e) {
59287       {
59288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59289       };
59290     } catch (Dali::DaliException e) {
59291       {
59292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59293       };
59294     } catch (...) {
59295       {
59296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59297       };
59298     }
59299   }
59300
59301   jresult = (int)result;
59302   return jresult;
59303 }
59304
59305
59306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
59307   int jresult ;
59308   int result;
59309
59310   {
59311     try {
59312       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
59313     } catch (std::out_of_range& e) {
59314       {
59315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59316       };
59317     } catch (std::exception& e) {
59318       {
59319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59320       };
59321     } catch (Dali::DaliException e) {
59322       {
59323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59324       };
59325     } catch (...) {
59326       {
59327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59328       };
59329     }
59330   }
59331
59332   jresult = (int)result;
59333   return jresult;
59334 }
59335
59336
59337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
59338   int jresult ;
59339   int result;
59340
59341   {
59342     try {
59343       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
59344     } catch (std::out_of_range& e) {
59345       {
59346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59347       };
59348     } catch (std::exception& e) {
59349       {
59350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59351       };
59352     } catch (Dali::DaliException e) {
59353       {
59354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59355       };
59356     } catch (...) {
59357       {
59358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59359       };
59360     }
59361   }
59362
59363   jresult = (int)result;
59364   return jresult;
59365 }
59366
59367
59368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
59369   int jresult ;
59370   int result;
59371
59372   {
59373     try {
59374       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
59375     } catch (std::out_of_range& e) {
59376       {
59377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59378       };
59379     } catch (std::exception& e) {
59380       {
59381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59382       };
59383     } catch (Dali::DaliException e) {
59384       {
59385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59386       };
59387     } catch (...) {
59388       {
59389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59390       };
59391     }
59392   }
59393
59394   jresult = (int)result;
59395   return jresult;
59396 }
59397
59398
59399 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
59400   int jresult ;
59401   int result;
59402
59403   {
59404     try {
59405       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
59406     } catch (std::out_of_range& e) {
59407       {
59408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59409       };
59410     } catch (std::exception& e) {
59411       {
59412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59413       };
59414     } catch (Dali::DaliException e) {
59415       {
59416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59417       };
59418     } catch (...) {
59419       {
59420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59421       };
59422     }
59423   }
59424
59425   jresult = (int)result;
59426   return jresult;
59427 }
59428
59429
59430 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
59431   int jresult ;
59432   int result;
59433
59434   {
59435     try {
59436       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
59437     } catch (std::out_of_range& e) {
59438       {
59439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59440       };
59441     } catch (std::exception& e) {
59442       {
59443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59444       };
59445     } catch (Dali::DaliException e) {
59446       {
59447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59448       };
59449     } catch (...) {
59450       {
59451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59452       };
59453     }
59454   }
59455
59456   jresult = (int)result;
59457   return jresult;
59458 }
59459
59460
59461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
59462   int jresult ;
59463   int result;
59464
59465   {
59466     try {
59467       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
59468     } catch (std::out_of_range& e) {
59469       {
59470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59471       };
59472     } catch (std::exception& e) {
59473       {
59474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59475       };
59476     } catch (Dali::DaliException e) {
59477       {
59478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59479       };
59480     } catch (...) {
59481       {
59482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59483       };
59484     }
59485   }
59486
59487   jresult = (int)result;
59488   return jresult;
59489 }
59490
59491
59492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
59493   int jresult ;
59494   int result;
59495
59496   {
59497     try {
59498       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
59499     } catch (std::out_of_range& e) {
59500       {
59501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59502       };
59503     } catch (std::exception& e) {
59504       {
59505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59506       };
59507     } catch (Dali::DaliException e) {
59508       {
59509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59510       };
59511     } catch (...) {
59512       {
59513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59514       };
59515     }
59516   }
59517
59518   jresult = (int)result;
59519   return jresult;
59520 }
59521
59522
59523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
59524   int jresult ;
59525   int result;
59526
59527   {
59528     try {
59529       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
59530     } catch (std::out_of_range& e) {
59531       {
59532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59533       };
59534     } catch (std::exception& e) {
59535       {
59536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59537       };
59538     } catch (Dali::DaliException e) {
59539       {
59540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59541       };
59542     } catch (...) {
59543       {
59544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59545       };
59546     }
59547   }
59548
59549   jresult = (int)result;
59550   return jresult;
59551 }
59552
59553
59554 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
59555   int jresult ;
59556   int result;
59557
59558   {
59559     try {
59560       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
59561     } catch (std::out_of_range& e) {
59562       {
59563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59564       };
59565     } catch (std::exception& e) {
59566       {
59567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59568       };
59569     } catch (Dali::DaliException e) {
59570       {
59571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59572       };
59573     } catch (...) {
59574       {
59575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59576       };
59577     }
59578   }
59579
59580   jresult = (int)result;
59581   return jresult;
59582 }
59583
59584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
59585   int jresult ;
59586   int result;
59587
59588   {
59589     try {
59590       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
59591     } catch (std::out_of_range& e) {
59592       {
59593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59594       };
59595     } catch (std::exception& e) {
59596       {
59597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59598       };
59599     } catch (Dali::DaliException e) {
59600       {
59601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59602       };
59603     } catch (...) {
59604       {
59605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59606       };
59607     }
59608   }
59609
59610   jresult = (int)result;
59611   return jresult;
59612 }
59613
59614
59615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
59616   int jresult ;
59617   int result;
59618   {
59619     try
59620     {
59621       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
59622     } catch (std::out_of_range& e) {
59623       {
59624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59625       };
59626     } catch (std::exception& e) {
59627       {
59628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59629       };
59630     } catch (Dali::DaliException e) {
59631       {
59632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59633       };
59634     } catch (...) {
59635       {
59636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59637       };
59638     }
59639   }
59640
59641   jresult = (int)result;
59642   return jresult;
59643 }
59644
59645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
59646   int jresult ;
59647   int result;
59648   {
59649     try
59650     {
59651       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
59652     } catch (std::out_of_range& e) {
59653       {
59654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59655       };
59656     } catch (std::exception& e) {
59657       {
59658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59659       };
59660     } catch (Dali::DaliException e) {
59661       {
59662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59663       };
59664     } catch (...) {
59665       {
59666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59667       };
59668     }
59669   }
59670
59671   jresult = (int)result;
59672   return jresult;
59673 }
59674
59675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
59676   int jresult ;
59677   int result;
59678   {
59679     try
59680     {
59681       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
59682     } catch (std::out_of_range& e) {
59683       {
59684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59685       };
59686     } catch (std::exception& e) {
59687       {
59688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59689       };
59690     } catch (Dali::DaliException e) {
59691       {
59692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59693       };
59694     } catch (...) {
59695       {
59696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59697       };
59698     }
59699   }
59700
59701   jresult = (int)result;
59702   return jresult;
59703 }
59704
59705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
59706   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
59707 }
59708
59709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
59710   int jresult ;
59711   int result;
59712   {
59713     try
59714     {
59715       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
59716     } catch (std::out_of_range& e) {
59717       {
59718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59719       };
59720     } catch (std::exception& e) {
59721       {
59722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59723       };
59724     } catch (Dali::DaliException e) {
59725       {
59726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59727       };
59728     } catch (...) {
59729       {
59730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59731       };
59732     }
59733   }
59734
59735   jresult = (int)result;
59736   return jresult;
59737 }
59738
59739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
59740   int jresult ;
59741   int result;
59742   {
59743     try
59744     {
59745       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
59746     } catch (std::out_of_range& e) {
59747       {
59748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59749       };
59750     } catch (std::exception& e) {
59751       {
59752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59753       };
59754     } catch (Dali::DaliException e) {
59755       {
59756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59757       };
59758     } catch (...) {
59759       {
59760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59761       };
59762     }
59763   }
59764
59765   jresult = (int)result;
59766   return jresult;
59767 }
59768
59769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
59770   int jresult ;
59771   int result;
59772
59773   {
59774     try {
59775       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
59776     } catch (std::out_of_range& e) {
59777       {
59778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59779       };
59780     } catch (std::exception& e) {
59781       {
59782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59783       };
59784     } catch (Dali::DaliException e) {
59785       {
59786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59787       };
59788     } catch (...) {
59789       {
59790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59791       };
59792     }
59793   }
59794
59795   jresult = (int)result;
59796   return jresult;
59797 }
59798
59799
59800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
59801   int jresult ;
59802   int result;
59803
59804   {
59805     try {
59806       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
59807     } catch (std::out_of_range& e) {
59808       {
59809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59810       };
59811     } catch (std::exception& e) {
59812       {
59813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59814       };
59815     } catch (Dali::DaliException e) {
59816       {
59817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59818       };
59819     } catch (...) {
59820       {
59821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59822       };
59823     }
59824   }
59825
59826   jresult = (int)result;
59827   return jresult;
59828 }
59829
59830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
59831   int jresult ;
59832   int result;
59833   {
59834     try
59835     {
59836       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
59837     } catch (std::out_of_range& e) {
59838       {
59839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59840       };
59841     } catch (std::exception& e) {
59842       {
59843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59844       };
59845     } catch (...) {
59846       {
59847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59848       };
59849     }
59850   }
59851   jresult = (int)result;
59852   return jresult;
59853 }
59854
59855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
59856   int jresult ;
59857   int result;
59858   {
59859     try
59860     {
59861       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
59862     } catch (std::out_of_range& e) {
59863       {
59864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59865       };
59866     } catch (std::exception& e) {
59867       {
59868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59869       };
59870     } catch (...) {
59871       {
59872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59873       };
59874     }
59875   }
59876   jresult = (int)result;
59877   return jresult;
59878 }
59879
59880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
59881   int jresult ;
59882   int result;
59883   {
59884     try
59885     {
59886       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
59887     } catch (std::out_of_range& e) {
59888       {
59889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59890       };
59891     } catch (std::exception& e) {
59892       {
59893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59894       };
59895     } catch (...) {
59896       {
59897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59898       };
59899     }
59900   }
59901   jresult = (int)result;
59902   return jresult;
59903 }
59904
59905
59906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
59907   int jresult ;
59908   int result;
59909   {
59910     try
59911     {
59912       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
59913     } catch (std::out_of_range& e) {
59914       {
59915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59916       };
59917     } catch (std::exception& e) {
59918       {
59919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59920       };
59921     } catch (...) {
59922       {
59923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59924       };
59925     }
59926   }
59927   jresult = (int)result;
59928   return jresult;
59929 }
59930
59931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
59932   int jresult ;
59933   int result;
59934   {
59935     try
59936     {
59937       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
59938     } catch (std::out_of_range& e) {
59939       {
59940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59941       };
59942     } catch (std::exception& e) {
59943       {
59944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59945       };
59946     } catch (...) {
59947       {
59948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59949       };
59950     }
59951   }
59952   jresult = (int)result;
59953   return jresult;
59954 }
59955
59956
59957
59958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
59959   int jresult ;
59960   int result;
59961
59962   {
59963     try {
59964       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
59965     } catch (std::out_of_range& e) {
59966       {
59967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59968       };
59969     } catch (std::exception& e) {
59970       {
59971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59972       };
59973     } catch (Dali::DaliException e) {
59974       {
59975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59976       };
59977     } catch (...) {
59978       {
59979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59980       };
59981     }
59982   }
59983
59984   jresult = (int)result;
59985   return jresult;
59986 }
59987
59988
59989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
59990   int jresult ;
59991   int result;
59992
59993   {
59994     try {
59995       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
59996     } catch (std::out_of_range& e) {
59997       {
59998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59999       };
60000     } catch (std::exception& e) {
60001       {
60002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60003       };
60004     } catch (Dali::DaliException e) {
60005       {
60006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60007       };
60008     } catch (...) {
60009       {
60010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60011       };
60012     }
60013   }
60014
60015   jresult = (int)result;
60016   return jresult;
60017 }
60018
60019
60020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
60021   int jresult ;
60022   int result;
60023
60024   {
60025     try {
60026       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
60027     } catch (std::out_of_range& e) {
60028       {
60029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60030       };
60031     } catch (std::exception& e) {
60032       {
60033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60034       };
60035     } catch (Dali::DaliException e) {
60036       {
60037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60038       };
60039     } catch (...) {
60040       {
60041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60042       };
60043     }
60044   }
60045
60046   jresult = (int)result;
60047   return jresult;
60048 }
60049
60050
60051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
60052   int jresult ;
60053   int result;
60054
60055   {
60056     try {
60057       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
60058     } catch (std::out_of_range& e) {
60059       {
60060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60061       };
60062     } catch (std::exception& e) {
60063       {
60064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60065       };
60066     } catch (Dali::DaliException e) {
60067       {
60068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60069       };
60070     } catch (...) {
60071       {
60072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60073       };
60074     }
60075   }
60076
60077   jresult = (int)result;
60078   return jresult;
60079 }
60080
60081
60082 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
60083   int jresult ;
60084   int result;
60085
60086   {
60087     try {
60088       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
60089     } catch (std::out_of_range& e) {
60090       {
60091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60092       };
60093     } catch (std::exception& e) {
60094       {
60095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60096       };
60097     } catch (Dali::DaliException e) {
60098       {
60099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60100       };
60101     } catch (...) {
60102       {
60103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60104       };
60105     }
60106   }
60107
60108   jresult = (int)result;
60109   return jresult;
60110 }
60111
60112
60113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
60114   int jresult ;
60115   int result;
60116
60117   {
60118     try {
60119       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
60120     } catch (std::out_of_range& e) {
60121       {
60122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60123       };
60124     } catch (std::exception& e) {
60125       {
60126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60127       };
60128     } catch (Dali::DaliException e) {
60129       {
60130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60131       };
60132     } catch (...) {
60133       {
60134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60135       };
60136     }
60137   }
60138
60139   jresult = (int)result;
60140   return jresult;
60141 }
60142
60143
60144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
60145   int jresult ;
60146   int result;
60147
60148   {
60149     try {
60150       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
60151     } catch (std::out_of_range& e) {
60152       {
60153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60154       };
60155     } catch (std::exception& e) {
60156       {
60157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60158       };
60159     } catch (Dali::DaliException e) {
60160       {
60161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60162       };
60163     } catch (...) {
60164       {
60165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60166       };
60167     }
60168   }
60169
60170   jresult = (int)result;
60171   return jresult;
60172 }
60173
60174 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
60175   int jresult ;
60176   int result;
60177
60178   {
60179     try {
60180       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
60181     } catch (std::out_of_range& e) {
60182       {
60183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60184       };
60185     } catch (std::exception& e) {
60186       {
60187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60188       };
60189     } catch (...) {
60190       {
60191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60192       };
60193     }
60194   }
60195   jresult = (int)result;
60196   return jresult;
60197 }
60198
60199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
60200   int jresult ;
60201   int result;
60202
60203   {
60204     try {
60205       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
60206     } catch (std::out_of_range& e) {
60207       {
60208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60209       };
60210     } catch (std::exception& e) {
60211       {
60212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60213       };
60214     } catch (Dali::DaliException e) {
60215       {
60216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60217       };
60218     } catch (...) {
60219       {
60220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60221       };
60222     }
60223   }
60224
60225   jresult = (int)result;
60226   return jresult;
60227 }
60228
60229
60230 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
60231   int jresult ;
60232   int result;
60233
60234   {
60235     try {
60236       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
60237     } catch (std::out_of_range& e) {
60238       {
60239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60240       };
60241     } catch (std::exception& e) {
60242       {
60243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60244       };
60245     } catch (Dali::DaliException e) {
60246       {
60247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60248       };
60249     } catch (...) {
60250       {
60251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60252       };
60253     }
60254   }
60255
60256   jresult = (int)result;
60257   return jresult;
60258 }
60259
60260
60261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
60262   int jresult ;
60263   int result;
60264
60265   {
60266     try {
60267       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
60268     } catch (std::out_of_range& e) {
60269       {
60270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60271       };
60272     } catch (std::exception& e) {
60273       {
60274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60275       };
60276     } catch (Dali::DaliException e) {
60277       {
60278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60279       };
60280     } catch (...) {
60281       {
60282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60283       };
60284     }
60285   }
60286
60287   jresult = (int)result;
60288   return jresult;
60289 }
60290
60291
60292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
60293   int jresult ;
60294   int result;
60295
60296   {
60297     try {
60298       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
60299     } catch (std::out_of_range& e) {
60300       {
60301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60302       };
60303     } catch (std::exception& e) {
60304       {
60305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60306       };
60307     } catch (Dali::DaliException e) {
60308       {
60309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60310       };
60311     } catch (...) {
60312       {
60313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60314       };
60315     }
60316   }
60317
60318   jresult = (int)result;
60319   return jresult;
60320 }
60321
60322
60323 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
60324   int jresult ;
60325   int result;
60326
60327   {
60328     try {
60329       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
60330     } catch (std::out_of_range& e) {
60331       {
60332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60333       };
60334     } catch (std::exception& e) {
60335       {
60336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60337       };
60338     } catch (Dali::DaliException e) {
60339       {
60340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60341       };
60342     } catch (...) {
60343       {
60344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60345       };
60346     }
60347   }
60348
60349   jresult = (int)result;
60350   return jresult;
60351 }
60352
60353
60354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
60355   int jresult ;
60356   int result;
60357
60358   {
60359     try {
60360       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
60361     } catch (std::out_of_range& e) {
60362       {
60363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60364       };
60365     } catch (std::exception& e) {
60366       {
60367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60368       };
60369     } catch (Dali::DaliException e) {
60370       {
60371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60372       };
60373     } catch (...) {
60374       {
60375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60376       };
60377     }
60378   }
60379
60380   jresult = (int)result;
60381   return jresult;
60382 }
60383
60384
60385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
60386   int jresult ;
60387   int result;
60388
60389   {
60390     try {
60391       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
60392     } catch (std::out_of_range& e) {
60393       {
60394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60395       };
60396     } catch (std::exception& e) {
60397       {
60398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60399       };
60400     } catch (Dali::DaliException e) {
60401       {
60402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60403       };
60404     } catch (...) {
60405       {
60406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60407       };
60408     }
60409   }
60410
60411   jresult = (int)result;
60412   return jresult;
60413 }
60414
60415
60416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
60417   int jresult ;
60418   int result;
60419
60420   {
60421     try {
60422       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
60423     } catch (std::out_of_range& e) {
60424       {
60425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60426       };
60427     } catch (std::exception& e) {
60428       {
60429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60430       };
60431     } catch (Dali::DaliException e) {
60432       {
60433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60434       };
60435     } catch (...) {
60436       {
60437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60438       };
60439     }
60440   }
60441
60442   jresult = (int)result;
60443   return jresult;
60444 }
60445
60446
60447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
60448   int jresult ;
60449   int result;
60450
60451   {
60452     try {
60453       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
60454     } catch (std::out_of_range& e) {
60455       {
60456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60457       };
60458     } catch (std::exception& e) {
60459       {
60460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60461       };
60462     } catch (Dali::DaliException e) {
60463       {
60464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60465       };
60466     } catch (...) {
60467       {
60468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60469       };
60470     }
60471   }
60472
60473   jresult = (int)result;
60474   return jresult;
60475 }
60476
60477
60478 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
60479   int jresult ;
60480   int result;
60481
60482   {
60483     try {
60484       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
60485     } catch (std::out_of_range& e) {
60486       {
60487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60488       };
60489     } catch (std::exception& e) {
60490       {
60491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60492       };
60493     } catch (Dali::DaliException e) {
60494       {
60495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60496       };
60497     } catch (...) {
60498       {
60499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60500       };
60501     }
60502   }
60503
60504   jresult = (int)result;
60505   return jresult;
60506 }
60507
60508
60509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
60510   int jresult ;
60511   int result;
60512
60513   {
60514     try {
60515       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
60516     } catch (std::out_of_range& e) {
60517       {
60518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60519       };
60520     } catch (std::exception& e) {
60521       {
60522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60523       };
60524     } catch (Dali::DaliException e) {
60525       {
60526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60527       };
60528     } catch (...) {
60529       {
60530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60531       };
60532     }
60533   }
60534
60535   jresult = (int)result;
60536   return jresult;
60537 }
60538
60539
60540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
60541   int jresult ;
60542   int result;
60543
60544   {
60545     try {
60546       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
60547     } catch (std::out_of_range& e) {
60548       {
60549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60550       };
60551     } catch (std::exception& e) {
60552       {
60553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60554       };
60555     } catch (Dali::DaliException e) {
60556       {
60557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60558       };
60559     } catch (...) {
60560       {
60561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60562       };
60563     }
60564   }
60565
60566   jresult = (int)result;
60567   return jresult;
60568 }
60569
60570
60571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
60572   int jresult ;
60573   int result;
60574
60575   {
60576     try {
60577       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
60578     } catch (std::out_of_range& e) {
60579       {
60580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60581       };
60582     } catch (std::exception& e) {
60583       {
60584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60585       };
60586     } catch (Dali::DaliException e) {
60587       {
60588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60589       };
60590     } catch (...) {
60591       {
60592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60593       };
60594     }
60595   }
60596
60597   jresult = (int)result;
60598   return jresult;
60599 }
60600
60601
60602 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
60603   int jresult ;
60604   int result;
60605
60606   {
60607     try {
60608       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
60609     } catch (std::out_of_range& e) {
60610       {
60611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60612       };
60613     } catch (std::exception& e) {
60614       {
60615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60616       };
60617     } catch (Dali::DaliException e) {
60618       {
60619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60620       };
60621     } catch (...) {
60622       {
60623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60624       };
60625     }
60626   }
60627
60628   jresult = (int)result;
60629   return jresult;
60630 }
60631
60632
60633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
60634   int jresult ;
60635   int result;
60636
60637   {
60638     try {
60639       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
60640     } catch (std::out_of_range& e) {
60641       {
60642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60643       };
60644     } catch (std::exception& e) {
60645       {
60646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60647       };
60648     } catch (Dali::DaliException e) {
60649       {
60650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60651       };
60652     } catch (...) {
60653       {
60654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60655       };
60656     }
60657   }
60658
60659   jresult = (int)result;
60660   return jresult;
60661 }
60662
60663
60664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
60665   int jresult ;
60666   int result;
60667
60668   {
60669     try {
60670       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
60671     } catch (std::out_of_range& e) {
60672       {
60673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60674       };
60675     } catch (std::exception& e) {
60676       {
60677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60678       };
60679     } catch (Dali::DaliException e) {
60680       {
60681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60682       };
60683     } catch (...) {
60684       {
60685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60686       };
60687     }
60688   }
60689
60690   jresult = (int)result;
60691   return jresult;
60692 }
60693
60694
60695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
60696   int jresult ;
60697   int result;
60698
60699   {
60700     try {
60701       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
60702     } catch (std::out_of_range& e) {
60703       {
60704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60705       };
60706     } catch (std::exception& e) {
60707       {
60708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60709       };
60710     } catch (Dali::DaliException e) {
60711       {
60712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60713       };
60714     } catch (...) {
60715       {
60716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60717       };
60718     }
60719   }
60720
60721   jresult = (int)result;
60722   return jresult;
60723 }
60724
60725
60726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
60727   int jresult ;
60728   int result;
60729
60730   {
60731     try {
60732       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
60733     } catch (std::out_of_range& e) {
60734       {
60735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60736       };
60737     } catch (std::exception& e) {
60738       {
60739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60740       };
60741     } catch (Dali::DaliException e) {
60742       {
60743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60744       };
60745     } catch (...) {
60746       {
60747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60748       };
60749     }
60750   }
60751
60752   jresult = (int)result;
60753   return jresult;
60754 }
60755
60756
60757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
60758   int jresult ;
60759   int result;
60760
60761   {
60762     try {
60763       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
60764     } catch (std::out_of_range& e) {
60765       {
60766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60767       };
60768     } catch (std::exception& e) {
60769       {
60770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60771       };
60772     } catch (Dali::DaliException e) {
60773       {
60774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60775       };
60776     } catch (...) {
60777       {
60778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60779       };
60780     }
60781   }
60782
60783   jresult = (int)result;
60784   return jresult;
60785 }
60786
60787
60788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
60789   int jresult ;
60790   int result;
60791
60792   {
60793     try {
60794       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
60795     } catch (std::out_of_range& e) {
60796       {
60797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60798       };
60799     } catch (std::exception& e) {
60800       {
60801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60802       };
60803     } catch (Dali::DaliException e) {
60804       {
60805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60806       };
60807     } catch (...) {
60808       {
60809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60810       };
60811     }
60812   }
60813
60814   jresult = (int)result;
60815   return jresult;
60816 }
60817
60818
60819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
60820   int jresult ;
60821   int result;
60822
60823   {
60824     try {
60825       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
60826     } catch (std::out_of_range& e) {
60827       {
60828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60829       };
60830     } catch (std::exception& e) {
60831       {
60832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60833       };
60834     } catch (Dali::DaliException e) {
60835       {
60836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60837       };
60838     } catch (...) {
60839       {
60840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60841       };
60842     }
60843   }
60844
60845   jresult = (int)result;
60846   return jresult;
60847 }
60848
60849
60850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
60851   int jresult ;
60852   int result;
60853
60854   {
60855     try {
60856       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
60857     } catch (std::out_of_range& e) {
60858       {
60859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60860       };
60861     } catch (std::exception& e) {
60862       {
60863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60864       };
60865     } catch (Dali::DaliException e) {
60866       {
60867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60868       };
60869     } catch (...) {
60870       {
60871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60872       };
60873     }
60874   }
60875
60876   jresult = (int)result;
60877   return jresult;
60878 }
60879
60880
60881 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
60882   int jresult ;
60883   int result;
60884
60885   {
60886     try {
60887       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
60888     } catch (std::out_of_range& e) {
60889       {
60890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60891       };
60892     } catch (std::exception& e) {
60893       {
60894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60895       };
60896     } catch (Dali::DaliException e) {
60897       {
60898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60899       };
60900     } catch (...) {
60901       {
60902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60903       };
60904     }
60905   }
60906
60907   jresult = (int)result;
60908   return jresult;
60909 }
60910
60911
60912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
60913   int jresult ;
60914   int result;
60915
60916   {
60917     try {
60918       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
60919     } catch (std::out_of_range& e) {
60920       {
60921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60922       };
60923     } catch (std::exception& e) {
60924       {
60925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60926       };
60927     } catch (Dali::DaliException e) {
60928       {
60929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60930       };
60931     } catch (...) {
60932       {
60933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60934       };
60935     }
60936   }
60937
60938   jresult = (int)result;
60939   return jresult;
60940 }
60941
60942
60943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
60944   int jresult ;
60945   int result;
60946
60947   {
60948     try {
60949       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
60950     } catch (std::out_of_range& e) {
60951       {
60952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60953       };
60954     } catch (std::exception& e) {
60955       {
60956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60957       };
60958     } catch (Dali::DaliException e) {
60959       {
60960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60961       };
60962     } catch (...) {
60963       {
60964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60965       };
60966     }
60967   }
60968
60969   jresult = (int)result;
60970   return jresult;
60971 }
60972
60973
60974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
60975   int jresult ;
60976   int result;
60977
60978   {
60979     try {
60980       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
60981     } catch (std::out_of_range& e) {
60982       {
60983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60984       };
60985     } catch (std::exception& e) {
60986       {
60987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60988       };
60989     } catch (Dali::DaliException e) {
60990       {
60991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60992       };
60993     } catch (...) {
60994       {
60995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60996       };
60997     }
60998   }
60999
61000   jresult = (int)result;
61001   return jresult;
61002 }
61003
61004
61005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
61006   int jresult ;
61007   int result;
61008
61009   {
61010     try {
61011       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
61012     } catch (std::out_of_range& e) {
61013       {
61014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61015       };
61016     } catch (std::exception& e) {
61017       {
61018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61019       };
61020     } catch (Dali::DaliException e) {
61021       {
61022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61023       };
61024     } catch (...) {
61025       {
61026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61027       };
61028     }
61029   }
61030
61031   jresult = (int)result;
61032   return jresult;
61033 }
61034
61035
61036 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
61037   int jresult ;
61038   int result;
61039
61040   {
61041     try {
61042       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
61043     } catch (std::out_of_range& e) {
61044       {
61045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61046       };
61047     } catch (std::exception& e) {
61048       {
61049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61050       };
61051     } catch (Dali::DaliException e) {
61052       {
61053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61054       };
61055     } catch (...) {
61056       {
61057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61058       };
61059     }
61060   }
61061
61062   jresult = (int)result;
61063   return jresult;
61064 }
61065
61066
61067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
61068   void * jresult ;
61069   Dali::Toolkit::Builder *result = 0 ;
61070
61071   {
61072     try {
61073       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
61074     } catch (std::out_of_range& e) {
61075       {
61076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61077       };
61078     } catch (std::exception& e) {
61079       {
61080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61081       };
61082     } catch (Dali::DaliException e) {
61083       {
61084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61085       };
61086     } catch (...) {
61087       {
61088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61089       };
61090     }
61091   }
61092
61093   jresult = (void *)result;
61094   return jresult;
61095 }
61096
61097
61098 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
61099   void * jresult ;
61100   Dali::Toolkit::Builder result;
61101
61102   {
61103     try {
61104       result = Dali::Toolkit::Builder::New();
61105     } catch (std::out_of_range& e) {
61106       {
61107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61108       };
61109     } catch (std::exception& e) {
61110       {
61111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61112       };
61113     } catch (Dali::DaliException e) {
61114       {
61115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61116       };
61117     } catch (...) {
61118       {
61119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61120       };
61121     }
61122   }
61123
61124   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
61125   return jresult;
61126 }
61127
61128
61129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
61130   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61131
61132   arg1 = (Dali::Toolkit::Builder *)jarg1;
61133   {
61134     try {
61135       delete arg1;
61136     } catch (std::out_of_range& e) {
61137       {
61138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61139       };
61140     } catch (std::exception& e) {
61141       {
61142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61143       };
61144     } catch (Dali::DaliException e) {
61145       {
61146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61147       };
61148     } catch (...) {
61149       {
61150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61151       };
61152     }
61153   }
61154
61155 }
61156
61157
61158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
61159   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61160   std::string *arg2 = 0 ;
61161   Dali::Toolkit::Builder::UIFormat arg3 ;
61162
61163   arg1 = (Dali::Toolkit::Builder *)jarg1;
61164   if (!jarg2) {
61165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61166     return ;
61167   }
61168   std::string arg2_str(jarg2);
61169   arg2 = &arg2_str;
61170   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
61171   {
61172     try {
61173       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
61174     } catch (std::out_of_range& e) {
61175       {
61176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61177       };
61178     } catch (std::exception& e) {
61179       {
61180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61181       };
61182     } catch (Dali::DaliException e) {
61183       {
61184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61185       };
61186     } catch (...) {
61187       {
61188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61189       };
61190     }
61191   }
61192
61193
61194   //argout typemap for const std::string&
61195
61196 }
61197
61198
61199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
61200   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61201   std::string *arg2 = 0 ;
61202
61203   arg1 = (Dali::Toolkit::Builder *)jarg1;
61204   if (!jarg2) {
61205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61206     return ;
61207   }
61208   std::string arg2_str(jarg2);
61209   arg2 = &arg2_str;
61210   {
61211     try {
61212       (arg1)->LoadFromString((std::string const &)*arg2);
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_AddConstants(void * jarg1, void * jarg2) {
61239   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61240   Dali::Property::Map *arg2 = 0 ;
61241
61242   arg1 = (Dali::Toolkit::Builder *)jarg1;
61243   arg2 = (Dali::Property::Map *)jarg2;
61244   if (!arg2) {
61245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61246     return ;
61247   }
61248   {
61249     try {
61250       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
61251     } catch (std::out_of_range& e) {
61252       {
61253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61254       };
61255     } catch (std::exception& e) {
61256       {
61257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61258       };
61259     } catch (Dali::DaliException e) {
61260       {
61261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61262       };
61263     } catch (...) {
61264       {
61265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61266       };
61267     }
61268   }
61269
61270 }
61271
61272
61273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
61274   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61275   std::string *arg2 = 0 ;
61276   Dali::Property::Value *arg3 = 0 ;
61277
61278   arg1 = (Dali::Toolkit::Builder *)jarg1;
61279   if (!jarg2) {
61280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61281     return ;
61282   }
61283   std::string arg2_str(jarg2);
61284   arg2 = &arg2_str;
61285   arg3 = (Dali::Property::Value *)jarg3;
61286   if (!arg3) {
61287     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
61288     return ;
61289   }
61290   {
61291     try {
61292       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
61293     } catch (std::out_of_range& e) {
61294       {
61295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61296       };
61297     } catch (std::exception& e) {
61298       {
61299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61300       };
61301     } catch (Dali::DaliException e) {
61302       {
61303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61304       };
61305     } catch (...) {
61306       {
61307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61308       };
61309     }
61310   }
61311
61312
61313   //argout typemap for const std::string&
61314
61315 }
61316
61317
61318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
61319   void * jresult ;
61320   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61321   Dali::Property::Map *result = 0 ;
61322
61323   arg1 = (Dali::Toolkit::Builder *)jarg1;
61324   {
61325     try {
61326       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
61327     } catch (std::out_of_range& e) {
61328       {
61329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61330       };
61331     } catch (std::exception& e) {
61332       {
61333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61334       };
61335     } catch (Dali::DaliException e) {
61336       {
61337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61338       };
61339     } catch (...) {
61340       {
61341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61342       };
61343     }
61344   }
61345
61346   jresult = (void *)result;
61347   return jresult;
61348 }
61349
61350
61351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
61352   void * jresult ;
61353   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61354   std::string *arg2 = 0 ;
61355   Dali::Property::Value *result = 0 ;
61356
61357   arg1 = (Dali::Toolkit::Builder *)jarg1;
61358   if (!jarg2) {
61359     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61360     return 0;
61361   }
61362   std::string arg2_str(jarg2);
61363   arg2 = &arg2_str;
61364   {
61365     try {
61366       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
61367     } catch (std::out_of_range& e) {
61368       {
61369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61370       };
61371     } catch (std::exception& e) {
61372       {
61373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61374       };
61375     } catch (Dali::DaliException e) {
61376       {
61377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61378       };
61379     } catch (...) {
61380       {
61381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61382       };
61383     }
61384   }
61385
61386   jresult = (void *)result;
61387
61388   //argout typemap for const std::string&
61389
61390   return jresult;
61391 }
61392
61393
61394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
61395   void * jresult ;
61396   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61397   std::string *arg2 = 0 ;
61398   Dali::Animation result;
61399
61400   arg1 = (Dali::Toolkit::Builder *)jarg1;
61401   if (!jarg2) {
61402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61403     return 0;
61404   }
61405   std::string arg2_str(jarg2);
61406   arg2 = &arg2_str;
61407   {
61408     try {
61409       result = (arg1)->CreateAnimation((std::string const &)*arg2);
61410     } catch (std::out_of_range& e) {
61411       {
61412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61413       };
61414     } catch (std::exception& e) {
61415       {
61416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61417       };
61418     } catch (Dali::DaliException e) {
61419       {
61420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61421       };
61422     } catch (...) {
61423       {
61424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61425       };
61426     }
61427   }
61428
61429   jresult = new Dali::Animation((const Dali::Animation &)result);
61430
61431   //argout typemap for const std::string&
61432
61433   return jresult;
61434 }
61435
61436
61437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61438   void * jresult ;
61439   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61440   std::string *arg2 = 0 ;
61441   Dali::Property::Map *arg3 = 0 ;
61442   Dali::Animation result;
61443
61444   arg1 = (Dali::Toolkit::Builder *)jarg1;
61445   if (!jarg2) {
61446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61447     return 0;
61448   }
61449   std::string arg2_str(jarg2);
61450   arg2 = &arg2_str;
61451   arg3 = (Dali::Property::Map *)jarg3;
61452   if (!arg3) {
61453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61454     return 0;
61455   }
61456   {
61457     try {
61458       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61459     } catch (std::out_of_range& e) {
61460       {
61461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61462       };
61463     } catch (std::exception& e) {
61464       {
61465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61466       };
61467     } catch (Dali::DaliException e) {
61468       {
61469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61470       };
61471     } catch (...) {
61472       {
61473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61474       };
61475     }
61476   }
61477
61478   jresult = new Dali::Animation((const Dali::Animation &)result);
61479
61480   //argout typemap for const std::string&
61481
61482   return jresult;
61483 }
61484
61485
61486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
61487   void * jresult ;
61488   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61489   std::string *arg2 = 0 ;
61490   Dali::Actor arg3 ;
61491   Dali::Actor *argp3 ;
61492   Dali::Animation result;
61493
61494   arg1 = (Dali::Toolkit::Builder *)jarg1;
61495   if (!jarg2) {
61496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61497     return 0;
61498   }
61499   std::string arg2_str(jarg2);
61500   arg2 = &arg2_str;
61501   argp3 = (Dali::Actor *)jarg3;
61502   if (!argp3) {
61503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61504     return 0;
61505   }
61506   arg3 = *argp3;
61507   {
61508     try {
61509       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
61510     } catch (std::out_of_range& e) {
61511       {
61512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61513       };
61514     } catch (std::exception& e) {
61515       {
61516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61517       };
61518     } catch (Dali::DaliException e) {
61519       {
61520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61521       };
61522     } catch (...) {
61523       {
61524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61525       };
61526     }
61527   }
61528
61529   jresult = new Dali::Animation((const Dali::Animation &)result);
61530
61531   //argout typemap for const std::string&
61532
61533   return jresult;
61534 }
61535
61536
61537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
61538   void * jresult ;
61539   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61540   std::string *arg2 = 0 ;
61541   Dali::Property::Map *arg3 = 0 ;
61542   Dali::Actor arg4 ;
61543   Dali::Actor *argp4 ;
61544   Dali::Animation result;
61545
61546   arg1 = (Dali::Toolkit::Builder *)jarg1;
61547   if (!jarg2) {
61548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61549     return 0;
61550   }
61551   std::string arg2_str(jarg2);
61552   arg2 = &arg2_str;
61553   arg3 = (Dali::Property::Map *)jarg3;
61554   if (!arg3) {
61555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61556     return 0;
61557   }
61558   argp4 = (Dali::Actor *)jarg4;
61559   if (!argp4) {
61560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61561     return 0;
61562   }
61563   arg4 = *argp4;
61564   {
61565     try {
61566       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
61567     } catch (std::out_of_range& e) {
61568       {
61569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61570       };
61571     } catch (std::exception& e) {
61572       {
61573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61574       };
61575     } catch (Dali::DaliException e) {
61576       {
61577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61578       };
61579     } catch (...) {
61580       {
61581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61582       };
61583     }
61584   }
61585
61586   jresult = new Dali::Animation((const Dali::Animation &)result);
61587
61588   //argout typemap for const std::string&
61589
61590   return jresult;
61591 }
61592
61593
61594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
61595   void * jresult ;
61596   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61597   std::string *arg2 = 0 ;
61598   Dali::BaseHandle result;
61599
61600   arg1 = (Dali::Toolkit::Builder *)jarg1;
61601   if (!jarg2) {
61602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61603     return 0;
61604   }
61605   std::string arg2_str(jarg2);
61606   arg2 = &arg2_str;
61607   {
61608     try {
61609       result = (arg1)->Create((std::string const &)*arg2);
61610     } catch (std::out_of_range& e) {
61611       {
61612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61613       };
61614     } catch (std::exception& e) {
61615       {
61616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61617       };
61618     } catch (Dali::DaliException e) {
61619       {
61620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61621       };
61622     } catch (...) {
61623       {
61624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61625       };
61626     }
61627   }
61628
61629   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61630
61631   //argout typemap for const std::string&
61632
61633   return jresult;
61634 }
61635
61636
61637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61638   void * jresult ;
61639   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61640   std::string *arg2 = 0 ;
61641   Dali::Property::Map *arg3 = 0 ;
61642   Dali::BaseHandle result;
61643
61644   arg1 = (Dali::Toolkit::Builder *)jarg1;
61645   if (!jarg2) {
61646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61647     return 0;
61648   }
61649   std::string arg2_str(jarg2);
61650   arg2 = &arg2_str;
61651   arg3 = (Dali::Property::Map *)jarg3;
61652   if (!arg3) {
61653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61654     return 0;
61655   }
61656   {
61657     try {
61658       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
61659     } catch (std::out_of_range& e) {
61660       {
61661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61662       };
61663     } catch (std::exception& e) {
61664       {
61665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61666       };
61667     } catch (Dali::DaliException e) {
61668       {
61669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61670       };
61671     } catch (...) {
61672       {
61673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61674       };
61675     }
61676   }
61677
61678   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61679
61680   //argout typemap for const std::string&
61681
61682   return jresult;
61683 }
61684
61685
61686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
61687   void * jresult ;
61688   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61689   std::string *arg2 = 0 ;
61690   Dali::BaseHandle result;
61691
61692   arg1 = (Dali::Toolkit::Builder *)jarg1;
61693   if (!jarg2) {
61694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61695     return 0;
61696   }
61697   std::string arg2_str(jarg2);
61698   arg2 = &arg2_str;
61699   {
61700     try {
61701       result = (arg1)->CreateFromJson((std::string const &)*arg2);
61702     } catch (std::out_of_range& e) {
61703       {
61704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61705       };
61706     } catch (std::exception& e) {
61707       {
61708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61709       };
61710     } catch (Dali::DaliException e) {
61711       {
61712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61713       };
61714     } catch (...) {
61715       {
61716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61717       };
61718     }
61719   }
61720
61721   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
61722
61723   //argout typemap for const std::string&
61724
61725   return jresult;
61726 }
61727
61728
61729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
61730   unsigned int jresult ;
61731   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61732   std::string *arg2 = 0 ;
61733   Dali::Handle *arg3 = 0 ;
61734   bool result;
61735
61736   arg1 = (Dali::Toolkit::Builder *)jarg1;
61737   if (!jarg2) {
61738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61739     return 0;
61740   }
61741   std::string arg2_str(jarg2);
61742   arg2 = &arg2_str;
61743   arg3 = (Dali::Handle *)jarg3;
61744   if (!arg3) {
61745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61746     return 0;
61747   }
61748   {
61749     try {
61750       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
61751     } catch (std::out_of_range& e) {
61752       {
61753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61754       };
61755     } catch (std::exception& e) {
61756       {
61757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61758       };
61759     } catch (Dali::DaliException e) {
61760       {
61761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61762       };
61763     } catch (...) {
61764       {
61765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61766       };
61767     }
61768   }
61769
61770   jresult = result;
61771
61772   //argout typemap for const std::string&
61773
61774   return jresult;
61775 }
61776
61777
61778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
61779   unsigned int jresult ;
61780   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61781   Dali::Handle *arg2 = 0 ;
61782   std::string *arg3 = 0 ;
61783   bool result;
61784
61785   arg1 = (Dali::Toolkit::Builder *)jarg1;
61786   arg2 = (Dali::Handle *)jarg2;
61787   if (!arg2) {
61788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
61789     return 0;
61790   }
61791   if (!jarg3) {
61792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61793     return 0;
61794   }
61795   std::string arg3_str(jarg3);
61796   arg3 = &arg3_str;
61797   {
61798     try {
61799       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
61800     } catch (std::out_of_range& e) {
61801       {
61802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61803       };
61804     } catch (std::exception& e) {
61805       {
61806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61807       };
61808     } catch (Dali::DaliException e) {
61809       {
61810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61811       };
61812     } catch (...) {
61813       {
61814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61815       };
61816     }
61817   }
61818
61819   jresult = result;
61820
61821   //argout typemap for const std::string&
61822
61823   return jresult;
61824 }
61825
61826
61827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
61828   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61829   Dali::Actor arg2 ;
61830   Dali::Actor *argp2 ;
61831
61832   arg1 = (Dali::Toolkit::Builder *)jarg1;
61833   argp2 = (Dali::Actor *)jarg2;
61834   if (!argp2) {
61835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61836     return ;
61837   }
61838   arg2 = *argp2;
61839   {
61840     try {
61841       (arg1)->AddActors(arg2);
61842     } catch (std::out_of_range& e) {
61843       {
61844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61845       };
61846     } catch (std::exception& e) {
61847       {
61848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61849       };
61850     } catch (Dali::DaliException e) {
61851       {
61852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61853       };
61854     } catch (...) {
61855       {
61856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61857       };
61858     }
61859   }
61860
61861 }
61862
61863
61864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
61865   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61866   std::string *arg2 = 0 ;
61867   Dali::Actor arg3 ;
61868   Dali::Actor *argp3 ;
61869
61870   arg1 = (Dali::Toolkit::Builder *)jarg1;
61871   if (!jarg2) {
61872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61873     return ;
61874   }
61875   std::string arg2_str(jarg2);
61876   arg2 = &arg2_str;
61877   argp3 = (Dali::Actor *)jarg3;
61878   if (!argp3) {
61879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
61880     return ;
61881   }
61882   arg3 = *argp3;
61883   {
61884     try {
61885       (arg1)->AddActors((std::string const &)*arg2,arg3);
61886     } catch (std::out_of_range& e) {
61887       {
61888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61889       };
61890     } catch (std::exception& e) {
61891       {
61892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61893       };
61894     } catch (Dali::DaliException e) {
61895       {
61896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61897       };
61898     } catch (...) {
61899       {
61900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61901       };
61902     }
61903   }
61904
61905
61906   //argout typemap for const std::string&
61907
61908 }
61909
61910
61911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
61912   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61913   std::string *arg2 = 0 ;
61914
61915   arg1 = (Dali::Toolkit::Builder *)jarg1;
61916   if (!jarg2) {
61917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61918     return ;
61919   }
61920   std::string arg2_str(jarg2);
61921   arg2 = &arg2_str;
61922   {
61923     try {
61924       (arg1)->CreateRenderTask((std::string const &)*arg2);
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_GetFrameBufferImage(void * jarg1, char * jarg2) {
61951   void * jresult ;
61952   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61953   std::string *arg2 = 0 ;
61954   Dali::FrameBufferImage result;
61955
61956   arg1 = (Dali::Toolkit::Builder *)jarg1;
61957   if (!jarg2) {
61958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61959     return 0;
61960   }
61961   std::string arg2_str(jarg2);
61962   arg2 = &arg2_str;
61963   {
61964     try {
61965       result = (arg1)->GetFrameBufferImage((std::string const &)*arg2);
61966     } catch (std::out_of_range& e) {
61967       {
61968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61969       };
61970     } catch (std::exception& e) {
61971       {
61972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61973       };
61974     } catch (Dali::DaliException e) {
61975       {
61976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61977       };
61978     } catch (...) {
61979       {
61980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61981       };
61982     }
61983   }
61984
61985   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
61986
61987   //argout typemap for const std::string&
61988
61989   return jresult;
61990 }
61991
61992
61993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
61994   void * jresult ;
61995   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
61996   std::string *arg2 = 0 ;
61997   Dali::Path result;
61998
61999   arg1 = (Dali::Toolkit::Builder *)jarg1;
62000   if (!jarg2) {
62001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62002     return 0;
62003   }
62004   std::string arg2_str(jarg2);
62005   arg2 = &arg2_str;
62006   {
62007     try {
62008       result = (arg1)->GetPath((std::string const &)*arg2);
62009     } catch (std::out_of_range& e) {
62010       {
62011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62012       };
62013     } catch (std::exception& e) {
62014       {
62015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62016       };
62017     } catch (Dali::DaliException e) {
62018       {
62019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62020       };
62021     } catch (...) {
62022       {
62023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62024       };
62025     }
62026   }
62027
62028   jresult = new Dali::Path((const Dali::Path &)result);
62029
62030   //argout typemap for const std::string&
62031
62032   return jresult;
62033 }
62034
62035
62036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
62037   void * jresult ;
62038   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62039   std::string *arg2 = 0 ;
62040   Dali::PathConstrainer result;
62041
62042   arg1 = (Dali::Toolkit::Builder *)jarg1;
62043   if (!jarg2) {
62044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62045     return 0;
62046   }
62047   std::string arg2_str(jarg2);
62048   arg2 = &arg2_str;
62049   {
62050     try {
62051       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
62052     } catch (std::out_of_range& e) {
62053       {
62054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62055       };
62056     } catch (std::exception& e) {
62057       {
62058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62059       };
62060     } catch (Dali::DaliException e) {
62061       {
62062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62063       };
62064     } catch (...) {
62065       {
62066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62067       };
62068     }
62069   }
62070
62071   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
62072
62073   //argout typemap for const std::string&
62074
62075   return jresult;
62076 }
62077
62078
62079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
62080   void * jresult ;
62081   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62082   std::string *arg2 = 0 ;
62083   Dali::LinearConstrainer result;
62084
62085   arg1 = (Dali::Toolkit::Builder *)jarg1;
62086   if (!jarg2) {
62087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62088     return 0;
62089   }
62090   std::string arg2_str(jarg2);
62091   arg2 = &arg2_str;
62092   {
62093     try {
62094       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
62095     } catch (std::out_of_range& e) {
62096       {
62097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62098       };
62099     } catch (std::exception& e) {
62100       {
62101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62102       };
62103     } catch (Dali::DaliException e) {
62104       {
62105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62106       };
62107     } catch (...) {
62108       {
62109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62110       };
62111     }
62112   }
62113
62114   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
62115
62116   //argout typemap for const std::string&
62117
62118   return jresult;
62119 }
62120
62121
62122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
62123   void * jresult ;
62124   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
62125   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
62126
62127   arg1 = (Dali::Toolkit::Builder *)jarg1;
62128   {
62129     try {
62130       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
62131     } catch (std::out_of_range& e) {
62132       {
62133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62134       };
62135     } catch (std::exception& e) {
62136       {
62137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62138       };
62139     } catch (Dali::DaliException e) {
62140       {
62141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62142       };
62143     } catch (...) {
62144       {
62145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62146       };
62147     }
62148   }
62149
62150   jresult = (void *)result;
62151   return jresult;
62152 }
62153
62154
62155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
62156   void * jresult ;
62157   Dali::Toolkit::TransitionData *result = 0 ;
62158
62159   {
62160     try {
62161       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
62162     } catch (std::out_of_range& e) {
62163       {
62164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62165       };
62166     } catch (std::exception& e) {
62167       {
62168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62169       };
62170     } catch (Dali::DaliException e) {
62171       {
62172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62173       };
62174     } catch (...) {
62175       {
62176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62177       };
62178     }
62179   }
62180
62181   jresult = (void *)result;
62182   return jresult;
62183 }
62184
62185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
62186   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62187
62188   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62189   {
62190     try {
62191       delete arg1;
62192     } catch (std::out_of_range& e) {
62193       {
62194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62195       };
62196     } catch (std::exception& e) {
62197       {
62198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62199       };
62200     } catch (Dali::DaliException e) {
62201       {
62202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62203       };
62204     } catch (...) {
62205       {
62206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62207       };
62208     }
62209   }
62210
62211 }
62212
62213
62214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
62215   void * jresult ;
62216   Dali::Property::Map *arg1 = 0 ;
62217   Dali::Toolkit::TransitionData result;
62218
62219   arg1 = (Dali::Property::Map *)jarg1;
62220   if (!arg1) {
62221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
62222     return 0;
62223   }
62224   {
62225     try {
62226       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
62227     } catch (std::out_of_range& e) {
62228       {
62229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62230       };
62231     } catch (std::exception& e) {
62232       {
62233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62234       };
62235     } catch (Dali::DaliException e) {
62236       {
62237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62238       };
62239     } catch (...) {
62240       {
62241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62242       };
62243     }
62244   }
62245
62246   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62247   return jresult;
62248 }
62249
62250
62251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
62252   void * jresult ;
62253   Dali::Property::Array *arg1 = 0 ;
62254   Dali::Toolkit::TransitionData result;
62255
62256   arg1 = (Dali::Property::Array *)jarg1;
62257   if (!arg1) {
62258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
62259     return 0;
62260   }
62261   {
62262     try {
62263       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
62264     } catch (std::out_of_range& e) {
62265       {
62266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62267       };
62268     } catch (std::exception& e) {
62269       {
62270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62271       };
62272     } catch (Dali::DaliException e) {
62273       {
62274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62275       };
62276     } catch (...) {
62277       {
62278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62279       };
62280     }
62281   }
62282
62283   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
62284   return jresult;
62285 }
62286
62287
62288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
62289   void * jresult ;
62290   Dali::BaseHandle arg1 ;
62291   Dali::BaseHandle *argp1 ;
62292   Dali::Toolkit::TransitionData result;
62293
62294   argp1 = (Dali::BaseHandle *)jarg1;
62295   if (!argp1) {
62296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
62297     return 0;
62298   }
62299   arg1 = *argp1;
62300   {
62301     try {
62302       result = Dali::Toolkit::TransitionData::DownCast(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_new_TransitionData__SWIG_1(void * jarg1) {
62328   void * jresult ;
62329   Dali::Toolkit::TransitionData *arg1 = 0 ;
62330   Dali::Toolkit::TransitionData *result = 0 ;
62331
62332   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62333   if (!arg1) {
62334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
62335     return 0;
62336   }
62337   {
62338     try {
62339       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
62340     } catch (std::out_of_range& e) {
62341       {
62342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62343       };
62344     } catch (std::exception& e) {
62345       {
62346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62347       };
62348     } catch (Dali::DaliException e) {
62349       {
62350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62351       };
62352     } catch (...) {
62353       {
62354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62355       };
62356     }
62357   }
62358
62359   jresult = (void *)result;
62360   return jresult;
62361 }
62362
62363
62364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
62365   void * jresult ;
62366   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62367   Dali::Toolkit::TransitionData *arg2 = 0 ;
62368   Dali::Toolkit::TransitionData *result = 0 ;
62369
62370   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62371   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
62372   if (!arg2) {
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 *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
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 unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
62404   unsigned long jresult ;
62405   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62406   size_t result;
62407
62408   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62409   {
62410     try {
62411       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
62412     } catch (std::out_of_range& e) {
62413       {
62414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62415       };
62416     } catch (std::exception& e) {
62417       {
62418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62419       };
62420     } catch (Dali::DaliException e) {
62421       {
62422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62423       };
62424     } catch (...) {
62425       {
62426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62427       };
62428     }
62429   }
62430
62431   jresult = (unsigned long)result;
62432   return jresult;
62433 }
62434
62435
62436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
62437   void * jresult ;
62438   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
62439   size_t arg2 ;
62440   Dali::Property::Map result;
62441
62442   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
62443   arg2 = (size_t)jarg2;
62444   {
62445     try {
62446       result = (arg1)->GetAnimatorAt(arg2);
62447     } catch (std::out_of_range& e) {
62448       {
62449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62450       };
62451     } catch (std::exception& e) {
62452       {
62453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62454       };
62455     } catch (Dali::DaliException e) {
62456       {
62457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62458       };
62459     } catch (...) {
62460       {
62461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62462       };
62463     }
62464   }
62465
62466   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
62467   return jresult;
62468 }
62469
62470
62471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
62472   int jresult ;
62473   int result;
62474
62475   {
62476     try {
62477       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
62478     } catch (std::out_of_range& e) {
62479       {
62480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62481       };
62482     } catch (std::exception& e) {
62483       {
62484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62485       };
62486     } catch (Dali::DaliException e) {
62487       {
62488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62489       };
62490     } catch (...) {
62491       {
62492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62493       };
62494     }
62495   }
62496
62497   jresult = (int)result;
62498   return jresult;
62499 }
62500
62501
62502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
62503   int jresult ;
62504   int result;
62505
62506   {
62507     try {
62508       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
62509     } catch (std::out_of_range& e) {
62510       {
62511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62512       };
62513     } catch (std::exception& e) {
62514       {
62515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62516       };
62517     } catch (Dali::DaliException e) {
62518       {
62519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62520       };
62521     } catch (...) {
62522       {
62523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62524       };
62525     }
62526   }
62527
62528   jresult = (int)result;
62529   return jresult;
62530 }
62531
62532
62533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
62534   int jresult ;
62535   int result;
62536
62537   {
62538     try {
62539       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
62540     } catch (std::out_of_range& e) {
62541       {
62542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62543       };
62544     } catch (std::exception& e) {
62545       {
62546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62547       };
62548     } catch (Dali::DaliException e) {
62549       {
62550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62551       };
62552     } catch (...) {
62553       {
62554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62555       };
62556     }
62557   }
62558
62559   jresult = (int)result;
62560   return jresult;
62561 }
62562
62563
62564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
62565   int jresult ;
62566   int result;
62567
62568   {
62569     try {
62570       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
62571     } catch (std::out_of_range& e) {
62572       {
62573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62574       };
62575     } catch (std::exception& e) {
62576       {
62577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62578       };
62579     } catch (Dali::DaliException e) {
62580       {
62581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62582       };
62583     } catch (...) {
62584       {
62585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62586       };
62587     }
62588   }
62589
62590   jresult = (int)result;
62591   return jresult;
62592 }
62593
62594
62595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
62596   int jresult ;
62597   int result;
62598
62599   {
62600     try {
62601       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
62602     } catch (std::out_of_range& e) {
62603       {
62604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62605       };
62606     } catch (std::exception& e) {
62607       {
62608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62609       };
62610     } catch (Dali::DaliException e) {
62611       {
62612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62613       };
62614     } catch (...) {
62615       {
62616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62617       };
62618     }
62619   }
62620
62621   jresult = (int)result;
62622   return jresult;
62623 }
62624
62625
62626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
62627   int jresult ;
62628   int result;
62629
62630   {
62631     try {
62632       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
62633     } catch (std::out_of_range& e) {
62634       {
62635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62636       };
62637     } catch (std::exception& e) {
62638       {
62639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62640       };
62641     } catch (Dali::DaliException e) {
62642       {
62643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62644       };
62645     } catch (...) {
62646       {
62647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62648       };
62649     }
62650   }
62651
62652   jresult = (int)result;
62653   return jresult;
62654 }
62655
62656
62657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
62658   int jresult ;
62659   int result;
62660
62661   {
62662     try {
62663       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
62664     } catch (std::out_of_range& e) {
62665       {
62666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62667       };
62668     } catch (std::exception& e) {
62669       {
62670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62671       };
62672     } catch (Dali::DaliException e) {
62673       {
62674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62675       };
62676     } catch (...) {
62677       {
62678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62679       };
62680     }
62681   }
62682
62683   jresult = (int)result;
62684   return jresult;
62685 }
62686
62687
62688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
62689   int jresult ;
62690   int result;
62691
62692   {
62693     try {
62694       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
62695     } catch (std::out_of_range& e) {
62696       {
62697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62698       };
62699     } catch (std::exception& e) {
62700       {
62701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62702       };
62703     } catch (Dali::DaliException e) {
62704       {
62705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62706       };
62707     } catch (...) {
62708       {
62709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62710       };
62711     }
62712   }
62713
62714   jresult = (int)result;
62715   return jresult;
62716 }
62717
62718
62719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
62720   int jresult ;
62721   int result;
62722
62723   {
62724     try {
62725       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
62726     } catch (std::out_of_range& e) {
62727       {
62728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62729       };
62730     } catch (std::exception& e) {
62731       {
62732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62733       };
62734     } catch (Dali::DaliException e) {
62735       {
62736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62737       };
62738     } catch (...) {
62739       {
62740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62741       };
62742     }
62743   }
62744
62745   jresult = (int)result;
62746   return jresult;
62747 }
62748
62749
62750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
62751   int jresult ;
62752   int result;
62753
62754   {
62755     try {
62756       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
62757     } catch (std::out_of_range& e) {
62758       {
62759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62760       };
62761     } catch (std::exception& e) {
62762       {
62763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62764       };
62765     } catch (Dali::DaliException e) {
62766       {
62767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62768       };
62769     } catch (...) {
62770       {
62771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62772       };
62773     }
62774   }
62775
62776   jresult = (int)result;
62777   return jresult;
62778 }
62779
62780
62781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
62782   int jresult ;
62783   int result;
62784
62785   {
62786     try {
62787       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
62788     } catch (std::out_of_range& e) {
62789       {
62790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62791       };
62792     } catch (std::exception& e) {
62793       {
62794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62795       };
62796     } catch (Dali::DaliException e) {
62797       {
62798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62799       };
62800     } catch (...) {
62801       {
62802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62803       };
62804     }
62805   }
62806
62807   jresult = (int)result;
62808   return jresult;
62809 }
62810
62811
62812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
62813   int jresult ;
62814   int result;
62815
62816   {
62817     try {
62818       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
62819     } catch (std::out_of_range& e) {
62820       {
62821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62822       };
62823     } catch (std::exception& e) {
62824       {
62825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62826       };
62827     } catch (Dali::DaliException e) {
62828       {
62829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62830       };
62831     } catch (...) {
62832       {
62833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62834       };
62835     }
62836   }
62837
62838   jresult = (int)result;
62839   return jresult;
62840 }
62841
62842
62843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
62844   int jresult ;
62845   int result;
62846
62847   {
62848     try {
62849       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
62850     } catch (std::out_of_range& e) {
62851       {
62852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62853       };
62854     } catch (std::exception& e) {
62855       {
62856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62857       };
62858     } catch (Dali::DaliException e) {
62859       {
62860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62861       };
62862     } catch (...) {
62863       {
62864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62865       };
62866     }
62867   }
62868
62869   jresult = (int)result;
62870   return jresult;
62871 }
62872
62873
62874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
62875   int jresult ;
62876   int result;
62877
62878   {
62879     try {
62880       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
62881     } catch (std::out_of_range& e) {
62882       {
62883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62884       };
62885     } catch (std::exception& e) {
62886       {
62887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62888       };
62889     } catch (Dali::DaliException e) {
62890       {
62891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62892       };
62893     } catch (...) {
62894       {
62895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62896       };
62897     }
62898   }
62899
62900   jresult = (int)result;
62901   return jresult;
62902 }
62903
62904
62905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
62906   void * jresult ;
62907   Dali::Toolkit::Control result;
62908
62909   {
62910     try {
62911       result = Dali::Toolkit::Internal::Control::New();
62912     } catch (std::out_of_range& e) {
62913       {
62914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62915       };
62916     } catch (std::exception& e) {
62917       {
62918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62919       };
62920     } catch (Dali::DaliException e) {
62921       {
62922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62923       };
62924     } catch (...) {
62925       {
62926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62927       };
62928     }
62929   }
62930
62931   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
62932   return jresult;
62933 }
62934
62935
62936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
62937   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62938   std::string *arg2 = 0 ;
62939
62940   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62941   if (!jarg2) {
62942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
62943     return ;
62944   }
62945   std::string arg2_str(jarg2);
62946   arg2 = &arg2_str;
62947   {
62948     try {
62949       (arg1)->SetStyleName((std::string const &)*arg2);
62950     } catch (std::out_of_range& e) {
62951       {
62952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62953       };
62954     } catch (std::exception& e) {
62955       {
62956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62957       };
62958     } catch (Dali::DaliException e) {
62959       {
62960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62961       };
62962     } catch (...) {
62963       {
62964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62965       };
62966     }
62967   }
62968
62969
62970   //argout typemap for const std::string&
62971
62972 }
62973
62974
62975 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
62976   char * jresult ;
62977   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62978   std::string *result = 0 ;
62979
62980   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62981   {
62982     try {
62983       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
62984     } catch (std::out_of_range& e) {
62985       {
62986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62987       };
62988     } catch (std::exception& e) {
62989       {
62990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62991       };
62992     } catch (Dali::DaliException e) {
62993       {
62994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62995       };
62996     } catch (...) {
62997       {
62998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62999       };
63000     }
63001   }
63002
63003   jresult = SWIG_csharp_string_callback(result->c_str());
63004   return jresult;
63005 }
63006
63007
63008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
63009   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63010   Dali::Vector4 *arg2 = 0 ;
63011
63012   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63013   arg2 = (Dali::Vector4 *)jarg2;
63014   if (!arg2) {
63015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63016     return ;
63017   }
63018   {
63019     try {
63020       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63021     } catch (std::out_of_range& e) {
63022       {
63023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63024       };
63025     } catch (std::exception& e) {
63026       {
63027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63028       };
63029     } catch (Dali::DaliException e) {
63030       {
63031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63032       };
63033     } catch (...) {
63034       {
63035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63036       };
63037     }
63038   }
63039
63040 }
63041
63042
63043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
63044   void * jresult ;
63045   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63046   Dali::Vector4 result;
63047
63048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63049   {
63050     try {
63051       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetBackgroundColor();
63052     } catch (std::out_of_range& e) {
63053       {
63054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63055       };
63056     } catch (std::exception& e) {
63057       {
63058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63059       };
63060     } catch (Dali::DaliException e) {
63061       {
63062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63063       };
63064     } catch (...) {
63065       {
63066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63067       };
63068     }
63069   }
63070
63071   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
63072   return jresult;
63073 }
63074
63075
63076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundImage(void * jarg1, void * jarg2) {
63077   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63078   Dali::Image arg2 ;
63079   Dali::Image *argp2 ;
63080
63081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63082   argp2 = (Dali::Image *)jarg2;
63083   if (!argp2) {
63084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
63085     return ;
63086   }
63087   arg2 = *argp2;
63088   {
63089     try {
63090       (arg1)->SetBackgroundImage(arg2);
63091     } catch (std::out_of_range& e) {
63092       {
63093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63094       };
63095     } catch (std::exception& e) {
63096       {
63097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63098       };
63099     } catch (Dali::DaliException e) {
63100       {
63101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63102       };
63103     } catch (...) {
63104       {
63105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63106       };
63107     }
63108   }
63109
63110 }
63111
63112
63113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
63114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63115   Dali::Property::Map *arg2 = 0 ;
63116
63117   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63118   arg2 = (Dali::Property::Map *)jarg2;
63119   if (!arg2) {
63120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
63121     return ;
63122   }
63123   {
63124     try {
63125       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
63126     } catch (std::out_of_range& e) {
63127       {
63128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63129       };
63130     } catch (std::exception& e) {
63131       {
63132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63133       };
63134     } catch (Dali::DaliException e) {
63135       {
63136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63137       };
63138     } catch (...) {
63139       {
63140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63141       };
63142     }
63143   }
63144
63145 }
63146
63147
63148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
63149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63150
63151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63152   {
63153     try {
63154       (arg1)->ClearBackground();
63155     } catch (std::out_of_range& e) {
63156       {
63157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63158       };
63159     } catch (std::exception& e) {
63160       {
63161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63162       };
63163     } catch (Dali::DaliException e) {
63164       {
63165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63166       };
63167     } catch (...) {
63168       {
63169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63170       };
63171     }
63172   }
63173
63174 }
63175
63176
63177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
63178   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63179   Dali::Gesture::Type arg2 ;
63180
63181   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63182   arg2 = (Dali::Gesture::Type)jarg2;
63183   {
63184     try {
63185       (arg1)->EnableGestureDetection(arg2);
63186     } catch (std::out_of_range& e) {
63187       {
63188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63189       };
63190     } catch (std::exception& e) {
63191       {
63192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63193       };
63194     } catch (Dali::DaliException e) {
63195       {
63196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63197       };
63198     } catch (...) {
63199       {
63200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63201       };
63202     }
63203   }
63204
63205 }
63206
63207
63208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
63209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63210   Dali::Gesture::Type arg2 ;
63211
63212   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63213   arg2 = (Dali::Gesture::Type)jarg2;
63214   {
63215     try {
63216       (arg1)->DisableGestureDetection(arg2);
63217     } catch (std::out_of_range& e) {
63218       {
63219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63220       };
63221     } catch (std::exception& e) {
63222       {
63223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63224       };
63225     } catch (Dali::DaliException e) {
63226       {
63227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63228       };
63229     } catch (...) {
63230       {
63231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63232       };
63233     }
63234   }
63235
63236 }
63237
63238
63239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
63240   void * jresult ;
63241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63242   Dali::PinchGestureDetector result;
63243
63244   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63245   {
63246     try {
63247       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
63248     } catch (std::out_of_range& e) {
63249       {
63250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63251       };
63252     } catch (std::exception& e) {
63253       {
63254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63255       };
63256     } catch (Dali::DaliException e) {
63257       {
63258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63259       };
63260     } catch (...) {
63261       {
63262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63263       };
63264     }
63265   }
63266
63267   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63268   return jresult;
63269 }
63270
63271
63272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
63273   void * jresult ;
63274   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63275   Dali::PanGestureDetector result;
63276
63277   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63278   {
63279     try {
63280       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
63281     } catch (std::out_of_range& e) {
63282       {
63283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63284       };
63285     } catch (std::exception& e) {
63286       {
63287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63288       };
63289     } catch (Dali::DaliException e) {
63290       {
63291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63292       };
63293     } catch (...) {
63294       {
63295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63296       };
63297     }
63298   }
63299
63300   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63301   return jresult;
63302 }
63303
63304
63305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
63306   void * jresult ;
63307   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63308   Dali::TapGestureDetector result;
63309
63310   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63311   {
63312     try {
63313       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
63314     } catch (std::out_of_range& e) {
63315       {
63316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63317       };
63318     } catch (std::exception& e) {
63319       {
63320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63321       };
63322     } catch (Dali::DaliException e) {
63323       {
63324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63325       };
63326     } catch (...) {
63327       {
63328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63329       };
63330     }
63331   }
63332
63333   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63334   return jresult;
63335 }
63336
63337
63338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
63339   void * jresult ;
63340   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63341   Dali::LongPressGestureDetector result;
63342
63343   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63344   {
63345     try {
63346       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
63347     } catch (std::out_of_range& e) {
63348       {
63349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63350       };
63351     } catch (std::exception& e) {
63352       {
63353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63354       };
63355     } catch (Dali::DaliException e) {
63356       {
63357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63358       };
63359     } catch (...) {
63360       {
63361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63362       };
63363     }
63364   }
63365
63366   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63367   return jresult;
63368 }
63369
63370
63371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
63372   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63373   bool arg2 ;
63374
63375   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63376   arg2 = jarg2 ? true : false;
63377   {
63378     try {
63379       (arg1)->SetKeyboardNavigationSupport(arg2);
63380     } catch (std::out_of_range& e) {
63381       {
63382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63383       };
63384     } catch (std::exception& e) {
63385       {
63386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63387       };
63388     } catch (Dali::DaliException e) {
63389       {
63390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63391       };
63392     } catch (...) {
63393       {
63394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63395       };
63396     }
63397   }
63398
63399 }
63400
63401
63402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
63403   unsigned int jresult ;
63404   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63405   bool result;
63406
63407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63408   {
63409     try {
63410       result = (bool)(arg1)->IsKeyboardNavigationSupported();
63411     } catch (std::out_of_range& e) {
63412       {
63413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63414       };
63415     } catch (std::exception& e) {
63416       {
63417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63418       };
63419     } catch (Dali::DaliException e) {
63420       {
63421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63422       };
63423     } catch (...) {
63424       {
63425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63426       };
63427     }
63428   }
63429
63430   jresult = result;
63431   return jresult;
63432 }
63433
63434
63435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
63436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63437
63438   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63439   {
63440     try {
63441       (arg1)->SetKeyInputFocus();
63442     } catch (std::out_of_range& e) {
63443       {
63444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63445       };
63446     } catch (std::exception& e) {
63447       {
63448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63449       };
63450     } catch (Dali::DaliException e) {
63451       {
63452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63453       };
63454     } catch (...) {
63455       {
63456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63457       };
63458     }
63459   }
63460
63461 }
63462
63463
63464 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
63465   unsigned int jresult ;
63466   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63467   bool result;
63468
63469   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63470   {
63471     try {
63472       result = (bool)(arg1)->HasKeyInputFocus();
63473     } catch (std::out_of_range& e) {
63474       {
63475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63476       };
63477     } catch (std::exception& e) {
63478       {
63479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63480       };
63481     } catch (Dali::DaliException e) {
63482       {
63483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63484       };
63485     } catch (...) {
63486       {
63487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63488       };
63489     }
63490   }
63491
63492   jresult = result;
63493   return jresult;
63494 }
63495
63496
63497 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
63498   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63499
63500   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63501   {
63502     try {
63503       (arg1)->ClearKeyInputFocus();
63504     } catch (std::out_of_range& e) {
63505       {
63506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63507       };
63508     } catch (std::exception& e) {
63509       {
63510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63511       };
63512     } catch (Dali::DaliException e) {
63513       {
63514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63515       };
63516     } catch (...) {
63517       {
63518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63519       };
63520     }
63521   }
63522
63523 }
63524
63525
63526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
63527   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63528   bool arg2 ;
63529
63530   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63531   arg2 = jarg2 ? true : false;
63532   {
63533     try {
63534       (arg1)->SetAsKeyboardFocusGroup(arg2);
63535     } catch (std::out_of_range& e) {
63536       {
63537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63538       };
63539     } catch (std::exception& e) {
63540       {
63541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63542       };
63543     } catch (Dali::DaliException e) {
63544       {
63545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63546       };
63547     } catch (...) {
63548       {
63549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63550       };
63551     }
63552   }
63553
63554 }
63555
63556
63557 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
63558   unsigned int jresult ;
63559   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63560   bool result;
63561
63562   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63563   {
63564     try {
63565       result = (bool)(arg1)->IsKeyboardFocusGroup();
63566     } catch (std::out_of_range& e) {
63567       {
63568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63569       };
63570     } catch (std::exception& e) {
63571       {
63572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63573       };
63574     } catch (Dali::DaliException e) {
63575       {
63576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63577       };
63578     } catch (...) {
63579       {
63580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63581       };
63582     }
63583   }
63584
63585   jresult = result;
63586   return jresult;
63587 }
63588
63589
63590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
63591   void * jresult ;
63592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63593   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63594
63595   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63596   {
63597     try {
63598       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63599     } catch (std::out_of_range& e) {
63600       {
63601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63602       };
63603     } catch (std::exception& e) {
63604       {
63605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63606       };
63607     } catch (Dali::DaliException e) {
63608       {
63609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63610       };
63611     } catch (...) {
63612       {
63613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63614       };
63615     }
63616   }
63617
63618   jresult = (void *)result;
63619   return jresult;
63620 }
63621
63622
63623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
63624   void * jresult ;
63625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63626   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63627
63628   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63629   {
63630     try {
63631       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63632     } catch (std::out_of_range& e) {
63633       {
63634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63635       };
63636     } catch (std::exception& e) {
63637       {
63638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63639       };
63640     } catch (Dali::DaliException e) {
63641       {
63642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63643       };
63644     } catch (...) {
63645       {
63646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63647       };
63648     }
63649   }
63650
63651   jresult = (void *)result;
63652   return jresult;
63653 }
63654
63655
63656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
63657   void * jresult ;
63658   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63659   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63660
63661   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63662   {
63663     try {
63664       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
63665     } catch (std::out_of_range& e) {
63666       {
63667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63668       };
63669     } catch (std::exception& e) {
63670       {
63671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63672       };
63673     } catch (Dali::DaliException e) {
63674       {
63675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63676       };
63677     } catch (...) {
63678       {
63679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63680       };
63681     }
63682   }
63683
63684   jresult = (void *)result;
63685   return jresult;
63686 }
63687
63688
63689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
63690   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63691   int arg2 ;
63692   SwigDirector_ViewImpl *darg = 0;
63693
63694   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63695   arg2 = (int)jarg2;
63696   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63697   if(!darg) {
63698     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63699     return;
63700   }
63701   {
63702     try {
63703       if(darg) {
63704         (darg)->OnStageConnection(arg2);
63705       }
63706     } catch (std::out_of_range& e) {
63707       {
63708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63709       };
63710     } catch (std::exception& e) {
63711       {
63712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63713       };
63714     } catch (Dali::DaliException e) {
63715       {
63716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63717       };
63718     } catch (...) {
63719       {
63720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63721       };
63722     }
63723   }
63724
63725 }
63726
63727
63728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(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)->OnStageConnectionSwigPublic(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_OnStageDisconnection(void * jarg1) {
63768   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63769   SwigDirector_ViewImpl *darg = 0;
63770
63771   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63772   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63773   if(!darg) {
63774     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63775     return;
63776   }
63777   {
63778     try {
63779       if(darg) {
63780         (darg)->OnStageDisconnection();
63781       }
63782     } catch (std::out_of_range& e) {
63783       {
63784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63785       };
63786     } catch (std::exception& e) {
63787       {
63788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63789       };
63790     } catch (Dali::DaliException e) {
63791       {
63792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63793       };
63794     } catch (...) {
63795       {
63796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63797       };
63798     }
63799   }
63800
63801 }
63802
63803
63804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
63805   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63806   SwigDirector_ViewImpl *darg = 0;
63807
63808   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63809   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63810   if(!darg) {
63811     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63812     return;
63813   }
63814   {
63815     try {
63816       if(darg) {
63817         (darg)->OnStageDisconnectionSwigPublic();
63818       }
63819     } catch (std::out_of_range& e) {
63820       {
63821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63822       };
63823     } catch (std::exception& e) {
63824       {
63825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63826       };
63827     } catch (Dali::DaliException e) {
63828       {
63829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63830       };
63831     } catch (...) {
63832       {
63833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63834       };
63835     }
63836   }
63837
63838 }
63839
63840
63841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
63842   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63843   Dali::Actor *arg2 = 0 ;
63844   SwigDirector_ViewImpl *darg = 0;
63845
63846   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63847   arg2 = (Dali::Actor *)jarg2;
63848   if (!arg2) {
63849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63850     return ;
63851   }
63852   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63853   if(!darg) {
63854     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63855     return;
63856   }
63857   {
63858     try {
63859       if(darg) {
63860         (darg)->OnChildAdd(*arg2);
63861       }
63862     } catch (std::out_of_range& e) {
63863       {
63864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63865       };
63866     } catch (std::exception& e) {
63867       {
63868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63869       };
63870     } catch (Dali::DaliException e) {
63871       {
63872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63873       };
63874     } catch (...) {
63875       {
63876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63877       };
63878     }
63879   }
63880
63881 }
63882
63883
63884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63885   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63886   Dali::Actor *arg2 = 0 ;
63887   SwigDirector_ViewImpl *darg = 0;
63888
63889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63890   arg2 = (Dali::Actor *)jarg2;
63891   if (!arg2) {
63892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63893     return ;
63894   }
63895   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63896   if(!darg) {
63897     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63898     return;
63899   }
63900   {
63901     try {
63902       if(darg) {
63903           (darg)->OnChildAddSwigPublic(*arg2);
63904       }
63905     } catch (std::out_of_range& e) {
63906       {
63907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63908       };
63909     } catch (std::exception& e) {
63910       {
63911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63912       };
63913     } catch (Dali::DaliException e) {
63914       {
63915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63916       };
63917     } catch (...) {
63918       {
63919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63920       };
63921     }
63922   }
63923
63924 }
63925
63926
63927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
63928   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63929   Dali::Actor *arg2 = 0 ;
63930   SwigDirector_ViewImpl *darg = 0;
63931
63932   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63933   arg2 = (Dali::Actor *)jarg2;
63934   if (!arg2) {
63935     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63936     return ;
63937   }
63938   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63939   if(!darg) {
63940     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63941     return;
63942   }
63943   {
63944     try {
63945       if(darg) {
63946         (darg)->OnChildRemove(*arg2);
63947       }
63948     } catch (std::out_of_range& e) {
63949       {
63950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63951       };
63952     } catch (std::exception& e) {
63953       {
63954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63955       };
63956     } catch (Dali::DaliException e) {
63957       {
63958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63959       };
63960     } catch (...) {
63961       {
63962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63963       };
63964     }
63965   }
63966
63967 }
63968
63969
63970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63971   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63972   Dali::Actor *arg2 = 0 ;
63973   SwigDirector_ViewImpl *darg = 0;
63974
63975   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63976   arg2 = (Dali::Actor *)jarg2;
63977   if (!arg2) {
63978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
63979     return ;
63980   }
63981   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63982   if(!darg) {
63983     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63984     return;
63985   }
63986   {
63987     try {
63988       if(darg) {
63989         (darg)->OnChildRemoveSwigPublic(*arg2);
63990       }
63991     } catch (std::out_of_range& e) {
63992       {
63993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63994       };
63995     } catch (std::exception& e) {
63996       {
63997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63998       };
63999     } catch (Dali::DaliException e) {
64000       {
64001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64002       };
64003     } catch (...) {
64004       {
64005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64006       };
64007     }
64008   }
64009
64010 }
64011
64012
64013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
64014   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64015   Dali::Property::Index arg2 ;
64016   Dali::Property::Value arg3 ;
64017   Dali::Property::Value *argp3 ;
64018   SwigDirector_ViewImpl *darg = 0;
64019
64020   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64021   arg2 = (Dali::Property::Index)jarg2;
64022   argp3 = (Dali::Property::Value *)jarg3;
64023   if (!argp3) {
64024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64025     return ;
64026   }
64027   arg3 = *argp3;
64028   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64029   if (!darg) {
64030     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64031     return;
64032   }
64033   {
64034     try {
64035       (darg)->OnPropertySet(arg2,arg3);
64036     } catch (std::out_of_range& e) {
64037       {
64038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64039       };
64040     } catch (std::exception& e) {
64041       {
64042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64043       };
64044     } catch (Dali::DaliException e) {
64045       {
64046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64047       };
64048     } catch (...) {
64049       {
64050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64051       };
64052     }
64053   }
64054
64055 }
64056
64057
64058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
64059   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64060   Dali::Property::Index arg2 ;
64061   Dali::Property::Value arg3 ;
64062   Dali::Property::Value *argp3 ;
64063   SwigDirector_ViewImpl *darg = 0;
64064
64065   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64066   arg2 = (Dali::Property::Index)jarg2;
64067   argp3 = (Dali::Property::Value *)jarg3;
64068   if (!argp3) {
64069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
64070     return ;
64071   }
64072   arg3 = *argp3;
64073   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64074   if (!darg) {
64075     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64076     return;
64077   }
64078   {
64079     try {
64080       (darg)->OnPropertySetSwigPublic(arg2,arg3);
64081     } catch (std::out_of_range& e) {
64082       {
64083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64084       };
64085     } catch (std::exception& e) {
64086       {
64087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64088       };
64089     } catch (Dali::DaliException e) {
64090       {
64091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64092       };
64093     } catch (...) {
64094       {
64095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64096       };
64097     }
64098   }
64099
64100 }
64101
64102
64103 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
64104   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64105   Dali::Vector3 *arg2 = 0 ;
64106   SwigDirector_ViewImpl *darg = 0;
64107
64108   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64109   arg2 = (Dali::Vector3 *)jarg2;
64110   if (!arg2) {
64111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64112     return ;
64113   }
64114   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64115   if (!darg) {
64116     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64117     return;
64118   }
64119   {
64120     try {
64121       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
64122     } catch (std::out_of_range& e) {
64123       {
64124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64125       };
64126     } catch (std::exception& e) {
64127       {
64128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64129       };
64130     } catch (Dali::DaliException e) {
64131       {
64132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64133       };
64134     } catch (...) {
64135       {
64136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64137       };
64138     }
64139   }
64140
64141 }
64142
64143
64144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64145   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64146   Dali::Vector3 *arg2 = 0 ;
64147   SwigDirector_ViewImpl *darg = 0;
64148
64149   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64150   arg2 = (Dali::Vector3 *)jarg2;
64151   if (!arg2) {
64152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64153     return ;
64154   }
64155   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64156   if (!darg) {
64157     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64158     return;
64159   }
64160   {
64161     try {
64162       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
64163     } catch (std::out_of_range& e) {
64164       {
64165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64166       };
64167     } catch (std::exception& e) {
64168       {
64169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64170       };
64171     } catch (Dali::DaliException e) {
64172       {
64173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64174       };
64175     } catch (...) {
64176       {
64177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64178       };
64179     }
64180   }
64181
64182 }
64183
64184
64185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
64186   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64187   Dali::Animation *arg2 = 0 ;
64188   Dali::Vector3 *arg3 = 0 ;
64189   SwigDirector_ViewImpl *darg = 0;
64190
64191   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64192   arg2 = (Dali::Animation *)jarg2;
64193   if (!arg2) {
64194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64195     return ;
64196   }
64197   arg3 = (Dali::Vector3 *)jarg3;
64198   if (!arg3) {
64199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64200     return ;
64201   }
64202   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64203   if (!darg) {
64204     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64205     return;
64206   }
64207   {
64208     try {
64209       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
64210     } catch (std::out_of_range& e) {
64211       {
64212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64213       };
64214     } catch (std::exception& e) {
64215       {
64216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64217       };
64218     } catch (Dali::DaliException e) {
64219       {
64220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64221       };
64222     } catch (...) {
64223       {
64224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64225       };
64226     }
64227   }
64228
64229 }
64230
64231
64232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64234   Dali::Animation *arg2 = 0 ;
64235   Dali::Vector3 *arg3 = 0 ;
64236   SwigDirector_ViewImpl *darg = 0;
64237
64238   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64239   arg2 = (Dali::Animation *)jarg2;
64240   if (!arg2) {
64241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
64242     return ;
64243   }
64244   arg3 = (Dali::Vector3 *)jarg3;
64245   if (!arg3) {
64246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
64247     return ;
64248   }
64249   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64250   if (!darg) {
64251     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64252     return;
64253   }
64254   {
64255     try {
64256       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
64257     } catch (std::out_of_range& e) {
64258       {
64259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64260       };
64261     } catch (std::exception& e) {
64262       {
64263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64264       };
64265     } catch (Dali::DaliException e) {
64266       {
64267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64268       };
64269     } catch (...) {
64270       {
64271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64272       };
64273     }
64274   }
64275
64276 }
64277
64278
64279 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
64280   unsigned int jresult ;
64281   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64282   Dali::TouchEvent *arg2 = 0 ;
64283   SwigDirector_ViewImpl *darg = 0;
64284   bool result;
64285
64286   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64287   arg2 = (Dali::TouchEvent *)jarg2;
64288   if (!arg2) {
64289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64290     return 0;
64291   }
64292   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64293   if (!darg) {
64294     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64295     return 0;
64296   }
64297   {
64298     try {
64299       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
64300     } catch (std::out_of_range& e) {
64301       {
64302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64303       };
64304     } catch (std::exception& e) {
64305       {
64306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64307       };
64308     } catch (Dali::DaliException e) {
64309       {
64310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64311       };
64312     } catch (...) {
64313       {
64314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64315       };
64316     }
64317   }
64318
64319   jresult = result;
64320   return jresult;
64321 }
64322
64323
64324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64325   unsigned int jresult ;
64326   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64327   Dali::TouchEvent *arg2 = 0 ;
64328   SwigDirector_ViewImpl *darg = 0;
64329   bool result;
64330
64331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64332   arg2 = (Dali::TouchEvent *)jarg2;
64333   if (!arg2) {
64334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64335     return 0;
64336   }
64337   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64338   if (!darg) {
64339     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64340     return 0;
64341   }
64342   {
64343     try {
64344       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
64345     } catch (std::out_of_range& e) {
64346       {
64347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64348       };
64349     } catch (std::exception& e) {
64350       {
64351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64352       };
64353     } catch (Dali::DaliException e) {
64354       {
64355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64356       };
64357     } catch (...) {
64358       {
64359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64360       };
64361     }
64362   }
64363
64364   jresult = result;
64365   return jresult;
64366 }
64367
64368
64369 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
64370   unsigned int jresult ;
64371   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64372   Dali::HoverEvent *arg2 = 0 ;
64373   SwigDirector_ViewImpl *darg = 0;
64374   bool result;
64375
64376   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64377   arg2 = (Dali::HoverEvent *)jarg2;
64378   if (!arg2) {
64379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64380     return 0;
64381   }
64382   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64383   if (!darg) {
64384     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64385     return 0;
64386   }
64387   {
64388     try {
64389       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
64390     } catch (std::out_of_range& e) {
64391       {
64392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64393       };
64394     } catch (std::exception& e) {
64395       {
64396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64397       };
64398     } catch (Dali::DaliException e) {
64399       {
64400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64401       };
64402     } catch (...) {
64403       {
64404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64405       };
64406     }
64407   }
64408
64409   jresult = result;
64410   return jresult;
64411 }
64412
64413
64414 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64415   unsigned int jresult ;
64416   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64417   Dali::HoverEvent *arg2 = 0 ;
64418   SwigDirector_ViewImpl *darg = 0;
64419   bool result;
64420
64421   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64422   arg2 = (Dali::HoverEvent *)jarg2;
64423   if (!arg2) {
64424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
64425     return 0;
64426   }
64427   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64428   if (!darg) {
64429     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64430     return 0;
64431   }
64432   {
64433     try {
64434       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
64435     } catch (std::out_of_range& e) {
64436       {
64437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64438       };
64439     } catch (std::exception& e) {
64440       {
64441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64442       };
64443     } catch (Dali::DaliException e) {
64444       {
64445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64446       };
64447     } catch (...) {
64448       {
64449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64450       };
64451     }
64452   }
64453
64454   jresult = result;
64455   return jresult;
64456 }
64457
64458
64459 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
64460   unsigned int jresult ;
64461   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64462   Dali::KeyEvent *arg2 = 0 ;
64463   SwigDirector_ViewImpl *darg = 0;
64464   bool result;
64465
64466   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64467   arg2 = (Dali::KeyEvent *)jarg2;
64468   if (!arg2) {
64469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64470     return 0;
64471   }
64472   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64473   if (!darg) {
64474     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64475     return 0;
64476   }
64477   {
64478     try {
64479       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
64480     } catch (std::out_of_range& e) {
64481       {
64482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64483       };
64484     } catch (std::exception& e) {
64485       {
64486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64487       };
64488     } catch (Dali::DaliException e) {
64489       {
64490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64491       };
64492     } catch (...) {
64493       {
64494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64495       };
64496     }
64497   }
64498
64499   jresult = result;
64500   return jresult;
64501 }
64502
64503
64504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64505   unsigned int jresult ;
64506   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64507   Dali::KeyEvent *arg2 = 0 ;
64508   SwigDirector_ViewImpl *darg = 0;
64509   bool result;
64510
64511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64512   arg2 = (Dali::KeyEvent *)jarg2;
64513   if (!arg2) {
64514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
64515     return 0;
64516   }
64517   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64518   if (!darg) {
64519     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64520     return 0;
64521   }
64522   {
64523     try {
64524       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
64525     } catch (std::out_of_range& e) {
64526       {
64527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64528       };
64529     } catch (std::exception& e) {
64530       {
64531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64532       };
64533     } catch (Dali::DaliException e) {
64534       {
64535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64536       };
64537     } catch (...) {
64538       {
64539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64540       };
64541     }
64542   }
64543
64544   jresult = result;
64545   return jresult;
64546 }
64547
64548
64549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
64550   unsigned int jresult ;
64551   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64552   Dali::WheelEvent *arg2 = 0 ;
64553   SwigDirector_ViewImpl *darg = 0;
64554   bool result;
64555
64556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64557   arg2 = (Dali::WheelEvent *)jarg2;
64558   if (!arg2) {
64559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64560     return 0;
64561   }
64562   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64563   if (!darg) {
64564     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64565     return 0;
64566   }
64567   {
64568     try {
64569       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
64570     } catch (std::out_of_range& e) {
64571       {
64572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64573       };
64574     } catch (std::exception& e) {
64575       {
64576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64577       };
64578     } catch (Dali::DaliException e) {
64579       {
64580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64581       };
64582     } catch (...) {
64583       {
64584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64585       };
64586     }
64587   }
64588
64589   jresult = result;
64590   return jresult;
64591 }
64592
64593
64594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64595   unsigned int jresult ;
64596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64597   Dali::WheelEvent *arg2 = 0 ;
64598   SwigDirector_ViewImpl *darg = 0;
64599   bool result;
64600
64601   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64602   arg2 = (Dali::WheelEvent *)jarg2;
64603   if (!arg2) {
64604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
64605     return 0;
64606   }
64607   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64608   if (!darg) {
64609     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64610     return 0;
64611   }
64612   {
64613     try {
64614       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
64615     } catch (std::out_of_range& e) {
64616       {
64617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64618       };
64619     } catch (std::exception& e) {
64620       {
64621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64622       };
64623     } catch (Dali::DaliException e) {
64624       {
64625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64626       };
64627     } catch (...) {
64628       {
64629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64630       };
64631     }
64632   }
64633
64634   jresult = result;
64635   return jresult;
64636 }
64637
64638
64639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
64640   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64641   Dali::Vector2 *arg2 = 0 ;
64642   Dali::RelayoutContainer *arg3 = 0 ;
64643   SwigDirector_ViewImpl *darg = 0;
64644
64645   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64646   arg2 = (Dali::Vector2 *)jarg2;
64647   if (!arg2) {
64648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64649     return ;
64650   }
64651   arg3 = (Dali::RelayoutContainer *)jarg3;
64652   if (!arg3) {
64653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64654     return ;
64655   }
64656   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64657   if (!darg) {
64658     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64659     return;
64660   }
64661   {
64662     try {
64663       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
64664     } catch (std::out_of_range& e) {
64665       {
64666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64667       };
64668     } catch (std::exception& e) {
64669       {
64670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64671       };
64672     } catch (Dali::DaliException e) {
64673       {
64674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64675       };
64676     } catch (...) {
64677       {
64678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64679       };
64680     }
64681   }
64682
64683 }
64684
64685
64686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
64687   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64688   Dali::Vector2 *arg2 = 0 ;
64689   Dali::RelayoutContainer *arg3 = 0 ;
64690   SwigDirector_ViewImpl *darg = 0;
64691
64692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64693   arg2 = (Dali::Vector2 *)jarg2;
64694   if (!arg2) {
64695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
64696     return ;
64697   }
64698   arg3 = (Dali::RelayoutContainer *)jarg3;
64699   if (!arg3) {
64700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
64701     return ;
64702   }
64703   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64704   if (!darg) {
64705     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64706     return;
64707   }
64708   {
64709     try {
64710       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
64711     } catch (std::out_of_range& e) {
64712       {
64713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64714       };
64715     } catch (std::exception& e) {
64716       {
64717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64718       };
64719     } catch (Dali::DaliException e) {
64720       {
64721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64722       };
64723     } catch (...) {
64724       {
64725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64726       };
64727     }
64728   }
64729
64730 }
64731
64732
64733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
64734   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64735   Dali::ResizePolicy::Type arg2 ;
64736   Dali::Dimension::Type arg3 ;
64737   SwigDirector_ViewImpl *darg = 0;
64738
64739   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64740   arg2 = (Dali::ResizePolicy::Type)jarg2;
64741   arg3 = (Dali::Dimension::Type)jarg3;
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)->OnSetResizePolicy(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_OnSetResizePolicySwigExplicitViewImpl(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)->OnSetResizePolicySwigPublic(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_GetNaturalSize(void * jarg1) {
64812   void * jresult ;
64813   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64814   SwigDirector_ViewImpl *darg = 0;
64815   Dali::Vector3 result;
64816
64817   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64818   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64819   if (!darg) {
64820     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64821     return 0;
64822   }
64823   {
64824     try {
64825       result = (darg)->GetNaturalSize();
64826     } catch (std::out_of_range& e) {
64827       {
64828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64829       };
64830     } catch (std::exception& e) {
64831       {
64832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64833       };
64834     } catch (Dali::DaliException e) {
64835       {
64836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64837       };
64838     } catch (...) {
64839       {
64840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64841       };
64842     }
64843   }
64844
64845   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
64846   return jresult;
64847 }
64848
64849
64850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(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)->GetNaturalSizeSwigPublic();
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 float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
64890   float jresult ;
64891   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64892   Dali::Actor *arg2 = 0 ;
64893   Dali::Dimension::Type arg3 ;
64894   SwigDirector_ViewImpl *darg = 0;
64895   float result;
64896
64897   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64898   arg2 = (Dali::Actor *)jarg2;
64899   if (!arg2) {
64900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64901     return 0;
64902   }
64903   arg3 = (Dali::Dimension::Type)jarg3;
64904   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64905   if (!darg) {
64906     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64907     return 0;
64908   }
64909   {
64910     try {
64911       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
64912     } catch (std::out_of_range& e) {
64913       {
64914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64915       };
64916     } catch (std::exception& e) {
64917       {
64918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64919       };
64920     } catch (Dali::DaliException e) {
64921       {
64922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64923       };
64924     } catch (...) {
64925       {
64926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64927       };
64928     }
64929   }
64930
64931   jresult = result;
64932   return jresult;
64933 }
64934
64935
64936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64937   float jresult ;
64938   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64939   Dali::Actor *arg2 = 0 ;
64940   Dali::Dimension::Type arg3 ;
64941   SwigDirector_ViewImpl *darg = 0;
64942   float result;
64943
64944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64945   arg2 = (Dali::Actor *)jarg2;
64946   if (!arg2) {
64947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
64948     return 0;
64949   }
64950   arg3 = (Dali::Dimension::Type)jarg3;
64951   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64952   if (!darg) {
64953     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64954     return 0;
64955   }
64956   {
64957     try {
64958       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
64959     } catch (std::out_of_range& e) {
64960       {
64961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64962       };
64963     } catch (std::exception& e) {
64964       {
64965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64966       };
64967     } catch (Dali::DaliException e) {
64968       {
64969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64970       };
64971     } catch (...) {
64972       {
64973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64974       };
64975     }
64976   }
64977
64978   jresult = result;
64979   return jresult;
64980 }
64981
64982
64983 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
64984   float jresult ;
64985   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64986   float arg2 ;
64987   SwigDirector_ViewImpl *darg = 0;
64988   float result;
64989
64990   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64991   arg2 = (float)jarg2;
64992   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64993   if (!darg) {
64994     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64995     return 0;
64996   }
64997   {
64998     try {
64999       result = (float)(darg)->GetHeightForWidth(arg2);
65000     } catch (std::out_of_range& e) {
65001       {
65002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65003       };
65004     } catch (std::exception& e) {
65005       {
65006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65007       };
65008     } catch (Dali::DaliException e) {
65009       {
65010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65011       };
65012     } catch (...) {
65013       {
65014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65015       };
65016     }
65017   }
65018
65019   jresult = result;
65020   return jresult;
65021 }
65022
65023
65024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
65025   float jresult ;
65026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65027   float arg2 ;
65028   SwigDirector_ViewImpl *darg = 0;
65029   float result;
65030
65031   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65032   arg2 = (float)jarg2;
65033   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65034   if (!darg) {
65035     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65036     return 0;
65037   }
65038   {
65039     try {
65040       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
65041     } catch (std::out_of_range& e) {
65042       {
65043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65044       };
65045     } catch (std::exception& e) {
65046       {
65047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65048       };
65049     } catch (Dali::DaliException e) {
65050       {
65051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65052       };
65053     } catch (...) {
65054       {
65055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65056       };
65057     }
65058   }
65059
65060   jresult = result;
65061   return jresult;
65062 }
65063
65064
65065 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
65066   float jresult ;
65067   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65068   float arg2 ;
65069   SwigDirector_ViewImpl *darg = 0;
65070   float result;
65071
65072   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65073   arg2 = (float)jarg2;
65074   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65075   if (!darg) {
65076     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65077     return 0;
65078   }
65079   {
65080     try {
65081       result = (float)(darg)->GetWidthForHeight(arg2);
65082     } catch (std::out_of_range& e) {
65083       {
65084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65085       };
65086     } catch (std::exception& e) {
65087       {
65088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65089       };
65090     } catch (Dali::DaliException e) {
65091       {
65092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65093       };
65094     } catch (...) {
65095       {
65096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65097       };
65098     }
65099   }
65100
65101   jresult = result;
65102   return jresult;
65103 }
65104
65105
65106 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
65107   float jresult ;
65108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65109   float arg2 ;
65110   SwigDirector_ViewImpl *darg = 0;
65111   float result;
65112
65113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65114   arg2 = (float)jarg2;
65115   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65116   if (!darg) {
65117     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65118     return 0;
65119   }
65120   {
65121     try {
65122       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
65123     } catch (std::out_of_range& e) {
65124       {
65125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65126       };
65127     } catch (std::exception& e) {
65128       {
65129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65130       };
65131     } catch (Dali::DaliException e) {
65132       {
65133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65134       };
65135     } catch (...) {
65136       {
65137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65138       };
65139     }
65140   }
65141
65142   jresult = result;
65143   return jresult;
65144 }
65145
65146
65147 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
65148   unsigned int jresult ;
65149   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65150   Dali::Dimension::Type arg2 ;
65151   SwigDirector_ViewImpl *darg = 0;
65152   bool result;
65153
65154   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65155   arg2 = (Dali::Dimension::Type)jarg2;
65156   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65157   if (!darg) {
65158     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65159     return 0;
65160   }
65161   {
65162     try {
65163       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
65164     } catch (std::out_of_range& e) {
65165       {
65166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65167       };
65168     } catch (std::exception& e) {
65169       {
65170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65171       };
65172     } catch (Dali::DaliException e) {
65173       {
65174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65175       };
65176     } catch (...) {
65177       {
65178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65179       };
65180     }
65181   }
65182
65183   jresult = result;
65184   return jresult;
65185 }
65186
65187
65188 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
65189   unsigned int jresult ;
65190   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65191   Dali::Dimension::Type arg2 ;
65192   SwigDirector_ViewImpl *darg = 0;
65193   bool result;
65194
65195   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65196   arg2 = (Dali::Dimension::Type)jarg2;
65197   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65198   if (!darg) {
65199     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65200     return 0;
65201   }
65202   {
65203     try {
65204       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
65205     } catch (std::out_of_range& e) {
65206       {
65207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65208       };
65209     } catch (std::exception& e) {
65210       {
65211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65212       };
65213     } catch (Dali::DaliException e) {
65214       {
65215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65216       };
65217     } catch (...) {
65218       {
65219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65220       };
65221     }
65222   }
65223
65224   jresult = result;
65225   return jresult;
65226 }
65227
65228
65229 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
65230   unsigned int jresult ;
65231   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65232   SwigDirector_ViewImpl *darg = 0;
65233   bool result;
65234
65235   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
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)->RelayoutDependentOnChildren();
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_RelayoutDependentOnChildrenSwigExplicitViewImpl__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)->RelayoutDependentOnChildrenSwigPublic();
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 void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
65308   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65309   Dali::Dimension::Type arg2 ;
65310   SwigDirector_ViewImpl *darg = 0;
65311
65312   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65313   arg2 = (Dali::Dimension::Type)jarg2;
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;
65318   }
65319   {
65320     try {
65321       (darg)->OnCalculateRelayoutSize(arg2);
65322     } catch (std::out_of_range& e) {
65323       {
65324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65325       };
65326     } catch (std::exception& e) {
65327       {
65328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65329       };
65330     } catch (Dali::DaliException e) {
65331       {
65332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65333       };
65334     } catch (...) {
65335       {
65336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65337       };
65338     }
65339   }
65340
65341 }
65342
65343
65344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
65345   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65346   Dali::Dimension::Type arg2 ;
65347   SwigDirector_ViewImpl *darg = 0;
65348
65349   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65350   arg2 = (Dali::Dimension::Type)jarg2;
65351   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
65352   if (!darg) {
65353     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
65354     return;
65355   }
65356   {
65357     try {
65358       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
65359     } catch (std::out_of_range& e) {
65360       {
65361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65362       };
65363     } catch (std::exception& e) {
65364       {
65365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65366       };
65367     } catch (Dali::DaliException e) {
65368       {
65369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65370       };
65371     } catch (...) {
65372       {
65373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65374       };
65375     }
65376   }
65377
65378 }
65379
65380
65381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
65382   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65383   float arg2 ;
65384   Dali::Dimension::Type arg3 ;
65385   SwigDirector_ViewImpl *darg = 0;
65386
65387   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65388   arg2 = (float)jarg2;
65389   arg3 = (Dali::Dimension::Type)jarg3;
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)->OnLayoutNegotiated(arg2,arg3);
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_OnLayoutNegotiatedSwigExplicitViewImpl(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)->OnLayoutNegotiatedSwigPublic(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_OnInitialize(void * jarg1) {
65460   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65461
65462   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65463   {
65464     try {
65465       (arg1)->OnInitialize();
65466     } catch (std::out_of_range& e) {
65467       {
65468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65469       };
65470     } catch (std::exception& e) {
65471       {
65472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65473       };
65474     } catch (Dali::DaliException e) {
65475       {
65476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65477       };
65478     } catch (...) {
65479       {
65480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65481       };
65482     }
65483   }
65484
65485 }
65486
65487
65488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
65489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65490
65491   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65492   {
65493     try {
65494       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
65495     } catch (std::out_of_range& e) {
65496       {
65497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65498       };
65499     } catch (std::exception& e) {
65500       {
65501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65502       };
65503     } catch (Dali::DaliException e) {
65504       {
65505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65506       };
65507     } catch (...) {
65508       {
65509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65510       };
65511     }
65512   }
65513
65514 }
65515
65516
65517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
65518   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65519   Dali::Actor *arg2 = 0 ;
65520
65521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65522   arg2 = (Dali::Actor *)jarg2;
65523   if (!arg2) {
65524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65525     return ;
65526   }
65527   {
65528     try {
65529       (arg1)->OnControlChildAdd(*arg2);
65530     } catch (std::out_of_range& e) {
65531       {
65532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65533       };
65534     } catch (std::exception& e) {
65535       {
65536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65537       };
65538     } catch (Dali::DaliException e) {
65539       {
65540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65541       };
65542     } catch (...) {
65543       {
65544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65545       };
65546     }
65547   }
65548
65549 }
65550
65551
65552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65554   Dali::Actor *arg2 = 0 ;
65555
65556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65557   arg2 = (Dali::Actor *)jarg2;
65558   if (!arg2) {
65559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65560     return ;
65561   }
65562   {
65563     try {
65564       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
65565     } catch (std::out_of_range& e) {
65566       {
65567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65568       };
65569     } catch (std::exception& e) {
65570       {
65571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65572       };
65573     } catch (Dali::DaliException e) {
65574       {
65575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65576       };
65577     } catch (...) {
65578       {
65579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65580       };
65581     }
65582   }
65583
65584 }
65585
65586
65587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
65588   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65589   Dali::Actor *arg2 = 0 ;
65590
65591   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65592   arg2 = (Dali::Actor *)jarg2;
65593   if (!arg2) {
65594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65595     return ;
65596   }
65597   {
65598     try {
65599       (arg1)->OnControlChildRemove(*arg2);
65600     } catch (std::out_of_range& e) {
65601       {
65602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65603       };
65604     } catch (std::exception& e) {
65605       {
65606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65607       };
65608     } catch (Dali::DaliException e) {
65609       {
65610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65611       };
65612     } catch (...) {
65613       {
65614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65615       };
65616     }
65617   }
65618
65619 }
65620
65621
65622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65623   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65624   Dali::Actor *arg2 = 0 ;
65625
65626   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65627   arg2 = (Dali::Actor *)jarg2;
65628   if (!arg2) {
65629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
65630     return ;
65631   }
65632   {
65633     try {
65634       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
65635     } catch (std::out_of_range& e) {
65636       {
65637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65638       };
65639     } catch (std::exception& e) {
65640       {
65641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65642       };
65643     } catch (Dali::DaliException e) {
65644       {
65645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65646       };
65647     } catch (...) {
65648       {
65649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65650       };
65651     }
65652   }
65653
65654 }
65655
65656
65657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
65658   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65659   Dali::Toolkit::StyleManager arg2 ;
65660   Dali::StyleChange::Type arg3 ;
65661   Dali::Toolkit::StyleManager *argp2 ;
65662
65663   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65664   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
65665   if (!argp2) {
65666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
65667     return ;
65668   }
65669   arg2 = *argp2;
65670   arg3 = (Dali::StyleChange::Type)jarg3;
65671   {
65672     try {
65673       (arg1)->OnStyleChange(arg2,arg3);
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_OnStyleChangeSwigExplicitViewImpl(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)->Dali::Toolkit::Internal::Control::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 unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
65736   unsigned int jresult ;
65737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65738   bool result;
65739
65740   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65741   {
65742     try {
65743       result = (bool)(arg1)->OnAccessibilityActivated();
65744     } catch (std::out_of_range& e) {
65745       {
65746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65747       };
65748     } catch (std::exception& e) {
65749       {
65750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65751       };
65752     } catch (Dali::DaliException e) {
65753       {
65754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65755       };
65756     } catch (...) {
65757       {
65758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65759       };
65760     }
65761   }
65762
65763   jresult = result;
65764   return jresult;
65765 }
65766
65767
65768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
65769   unsigned int jresult ;
65770   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65771   bool result;
65772
65773   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65774   {
65775     try {
65776       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
65777     } catch (std::out_of_range& e) {
65778       {
65779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65780       };
65781     } catch (std::exception& e) {
65782       {
65783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65784       };
65785     } catch (Dali::DaliException e) {
65786       {
65787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65788       };
65789     } catch (...) {
65790       {
65791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65792       };
65793     }
65794   }
65795
65796   jresult = result;
65797   return jresult;
65798 }
65799
65800
65801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
65802   unsigned int jresult ;
65803   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65804   Dali::PanGesture arg2 ;
65805   Dali::PanGesture *argp2 ;
65806   bool result;
65807
65808   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65809   argp2 = (Dali::PanGesture *)jarg2;
65810   if (!argp2) {
65811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65812     return 0;
65813   }
65814   arg2 = *argp2;
65815   {
65816     try {
65817       result = (bool)(arg1)->OnAccessibilityPan(arg2);
65818     } catch (std::out_of_range& e) {
65819       {
65820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65821       };
65822     } catch (std::exception& e) {
65823       {
65824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65825       };
65826     } catch (Dali::DaliException e) {
65827       {
65828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65829       };
65830     } catch (...) {
65831       {
65832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65833       };
65834     }
65835   }
65836
65837   jresult = result;
65838   return jresult;
65839 }
65840
65841
65842 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65843   unsigned int jresult ;
65844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65845   Dali::PanGesture arg2 ;
65846   Dali::PanGesture *argp2 ;
65847   bool result;
65848
65849   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65850   argp2 = (Dali::PanGesture *)jarg2;
65851   if (!argp2) {
65852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
65853     return 0;
65854   }
65855   arg2 = *argp2;
65856   {
65857     try {
65858       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
65859     } catch (std::out_of_range& e) {
65860       {
65861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65862       };
65863     } catch (std::exception& e) {
65864       {
65865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65866       };
65867     } catch (Dali::DaliException e) {
65868       {
65869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65870       };
65871     } catch (...) {
65872       {
65873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65874       };
65875     }
65876   }
65877
65878   jresult = result;
65879   return jresult;
65880 }
65881
65882
65883 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
65884   unsigned int jresult ;
65885   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65886   Dali::TouchEvent *arg2 = 0 ;
65887   bool result;
65888
65889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65890   arg2 = (Dali::TouchEvent *)jarg2;
65891   if (!arg2) {
65892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
65893     return 0;
65894   }
65895   {
65896     try {
65897       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*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_OnAccessibilityTouchSwigExplicitViewImpl(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)->Dali::Toolkit::Internal::Control::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_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
65962   unsigned int jresult ;
65963   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65964   bool arg2 ;
65965   bool result;
65966
65967   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65968   arg2 = jarg2 ? true : false;
65969   {
65970     try {
65971       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
65972     } catch (std::out_of_range& e) {
65973       {
65974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65975       };
65976     } catch (std::exception& e) {
65977       {
65978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65979       };
65980     } catch (Dali::DaliException e) {
65981       {
65982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65983       };
65984     } catch (...) {
65985       {
65986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65987       };
65988     }
65989   }
65990
65991   jresult = result;
65992   return jresult;
65993 }
65994
65995
65996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
65997   unsigned int jresult ;
65998   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65999   bool arg2 ;
66000   bool result;
66001
66002   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66003   arg2 = jarg2 ? true : false;
66004   {
66005     try {
66006       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
66007     } catch (std::out_of_range& e) {
66008       {
66009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66010       };
66011     } catch (std::exception& e) {
66012       {
66013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66014       };
66015     } catch (Dali::DaliException e) {
66016       {
66017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66018       };
66019     } catch (...) {
66020       {
66021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66022       };
66023     }
66024   }
66025
66026   jresult = result;
66027   return jresult;
66028 }
66029
66030
66031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
66032   unsigned int jresult ;
66033   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66034   bool result;
66035
66036   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66037   {
66038     try {
66039       result = (bool)(arg1)->OnAccessibilityZoom();
66040     } catch (std::out_of_range& e) {
66041       {
66042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66043       };
66044     } catch (std::exception& e) {
66045       {
66046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66047       };
66048     } catch (Dali::DaliException e) {
66049       {
66050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66051       };
66052     } catch (...) {
66053       {
66054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66055       };
66056     }
66057   }
66058
66059   jresult = result;
66060   return jresult;
66061 }
66062
66063
66064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
66065   unsigned int jresult ;
66066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66067   bool result;
66068
66069   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66070   {
66071     try {
66072       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
66073     } catch (std::out_of_range& e) {
66074       {
66075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66076       };
66077     } catch (std::exception& e) {
66078       {
66079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66080       };
66081     } catch (Dali::DaliException e) {
66082       {
66083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66084       };
66085     } catch (...) {
66086       {
66087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66088       };
66089     }
66090   }
66091
66092   jresult = result;
66093   return jresult;
66094 }
66095
66096
66097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
66098   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66099
66100   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66101   {
66102     try {
66103       (arg1)->OnKeyInputFocusGained();
66104     } catch (std::out_of_range& e) {
66105       {
66106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66107       };
66108     } catch (std::exception& e) {
66109       {
66110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66111       };
66112     } catch (Dali::DaliException e) {
66113       {
66114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66115       };
66116     } catch (...) {
66117       {
66118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66119       };
66120     }
66121   }
66122
66123 }
66124
66125
66126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
66127   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66128
66129   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66130   {
66131     try {
66132       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
66133     } catch (std::out_of_range& e) {
66134       {
66135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66136       };
66137     } catch (std::exception& e) {
66138       {
66139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66140       };
66141     } catch (Dali::DaliException e) {
66142       {
66143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66144       };
66145     } catch (...) {
66146       {
66147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66148       };
66149     }
66150   }
66151
66152 }
66153
66154
66155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
66156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66157
66158   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66159   {
66160     try {
66161       (arg1)->OnKeyInputFocusLost();
66162     } catch (std::out_of_range& e) {
66163       {
66164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66165       };
66166     } catch (std::exception& e) {
66167       {
66168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66169       };
66170     } catch (Dali::DaliException e) {
66171       {
66172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66173       };
66174     } catch (...) {
66175       {
66176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66177       };
66178     }
66179   }
66180
66181 }
66182
66183
66184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
66185   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66186
66187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66188   {
66189     try {
66190       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
66191     } catch (std::out_of_range& e) {
66192       {
66193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66194       };
66195     } catch (std::exception& e) {
66196       {
66197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66198       };
66199     } catch (Dali::DaliException e) {
66200       {
66201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66202       };
66203     } catch (...) {
66204       {
66205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66206       };
66207     }
66208   }
66209
66210 }
66211
66212
66213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66214   void * jresult ;
66215   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66216   Dali::Actor arg2 ;
66217   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66218   bool arg4 ;
66219   Dali::Actor *argp2 ;
66220   Dali::Actor result;
66221
66222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66223   argp2 = (Dali::Actor *)jarg2;
66224   if (!argp2) {
66225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66226     return 0;
66227   }
66228   arg2 = *argp2;
66229   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66230   arg4 = jarg4 ? true : false;
66231   {
66232     try {
66233       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66234     } catch (std::out_of_range& e) {
66235       {
66236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66237       };
66238     } catch (std::exception& e) {
66239       {
66240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66241       };
66242     } catch (Dali::DaliException e) {
66243       {
66244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66245       };
66246     } catch (...) {
66247       {
66248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66249       };
66250     }
66251   }
66252
66253   jresult = new Dali::Actor((const Dali::Actor &)result);
66254   return jresult;
66255 }
66256
66257
66258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
66259   void * jresult ;
66260   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66261   Dali::Actor arg2 ;
66262   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
66263   bool arg4 ;
66264   Dali::Actor *argp2 ;
66265   Dali::Actor result;
66266
66267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66268   argp2 = (Dali::Actor *)jarg2;
66269   if (!argp2) {
66270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66271     return 0;
66272   }
66273   arg2 = *argp2;
66274   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
66275   arg4 = jarg4 ? true : false;
66276   {
66277     try {
66278       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
66279     } catch (std::out_of_range& e) {
66280       {
66281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66282       };
66283     } catch (std::exception& e) {
66284       {
66285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66286       };
66287     } catch (Dali::DaliException e) {
66288       {
66289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66290       };
66291     } catch (...) {
66292       {
66293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66294       };
66295     }
66296   }
66297
66298   jresult = new Dali::Actor((const Dali::Actor &)result);
66299   return jresult;
66300 }
66301
66302
66303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
66304   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66305   Dali::Actor arg2 ;
66306   Dali::Actor *argp2 ;
66307
66308   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66309   argp2 = (Dali::Actor *)jarg2;
66310   if (!argp2) {
66311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66312     return ;
66313   }
66314   arg2 = *argp2;
66315   {
66316     try {
66317       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
66318     } catch (std::out_of_range& e) {
66319       {
66320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66321       };
66322     } catch (std::exception& e) {
66323       {
66324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66325       };
66326     } catch (Dali::DaliException e) {
66327       {
66328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66329       };
66330     } catch (...) {
66331       {
66332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66333       };
66334     }
66335   }
66336
66337 }
66338
66339
66340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66341   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66342   Dali::Actor arg2 ;
66343   Dali::Actor *argp2 ;
66344
66345   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66346   argp2 = (Dali::Actor *)jarg2;
66347   if (!argp2) {
66348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
66349     return ;
66350   }
66351   arg2 = *argp2;
66352   {
66353     try {
66354       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
66355     } catch (std::out_of_range& e) {
66356       {
66357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66358       };
66359     } catch (std::exception& e) {
66360       {
66361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66362       };
66363     } catch (Dali::DaliException e) {
66364       {
66365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66366       };
66367     } catch (...) {
66368       {
66369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66370       };
66371     }
66372   }
66373
66374 }
66375
66376
66377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
66378   unsigned int jresult ;
66379   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66380   bool result;
66381
66382   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66383   {
66384     try {
66385       result = (bool)(arg1)->OnKeyboardEnter();
66386     } catch (std::out_of_range& e) {
66387       {
66388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66389       };
66390     } catch (std::exception& e) {
66391       {
66392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66393       };
66394     } catch (Dali::DaliException e) {
66395       {
66396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66397       };
66398     } catch (...) {
66399       {
66400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66401       };
66402     }
66403   }
66404
66405   jresult = result;
66406   return jresult;
66407 }
66408
66409
66410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
66411   unsigned int jresult ;
66412   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66413   bool result;
66414
66415   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66416   {
66417     try {
66418       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
66419     } catch (std::out_of_range& e) {
66420       {
66421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66422       };
66423     } catch (std::exception& e) {
66424       {
66425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66426       };
66427     } catch (Dali::DaliException e) {
66428       {
66429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66430       };
66431     } catch (...) {
66432       {
66433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66434       };
66435     }
66436   }
66437
66438   jresult = result;
66439   return jresult;
66440 }
66441
66442
66443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
66444   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66445   Dali::PinchGesture *arg2 = 0 ;
66446
66447   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66448   arg2 = (Dali::PinchGesture *)jarg2;
66449   if (!arg2) {
66450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66451     return ;
66452   }
66453   {
66454     try {
66455       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
66456     } catch (std::out_of_range& e) {
66457       {
66458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66459       };
66460     } catch (std::exception& e) {
66461       {
66462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66463       };
66464     } catch (Dali::DaliException e) {
66465       {
66466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66467       };
66468     } catch (...) {
66469       {
66470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66471       };
66472     }
66473   }
66474
66475 }
66476
66477
66478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66479   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66480   Dali::PinchGesture *arg2 = 0 ;
66481
66482   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66483   arg2 = (Dali::PinchGesture *)jarg2;
66484   if (!arg2) {
66485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
66486     return ;
66487   }
66488   {
66489     try {
66490       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
66491     } catch (std::out_of_range& e) {
66492       {
66493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66494       };
66495     } catch (std::exception& e) {
66496       {
66497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66498       };
66499     } catch (Dali::DaliException e) {
66500       {
66501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66502       };
66503     } catch (...) {
66504       {
66505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66506       };
66507     }
66508   }
66509
66510 }
66511
66512
66513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
66514   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66515   Dali::PanGesture *arg2 = 0 ;
66516
66517   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66518   arg2 = (Dali::PanGesture *)jarg2;
66519   if (!arg2) {
66520     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66521     return ;
66522   }
66523   {
66524     try {
66525       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
66526     } catch (std::out_of_range& e) {
66527       {
66528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66529       };
66530     } catch (std::exception& e) {
66531       {
66532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66533       };
66534     } catch (Dali::DaliException e) {
66535       {
66536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66537       };
66538     } catch (...) {
66539       {
66540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66541       };
66542     }
66543   }
66544
66545 }
66546
66547
66548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66549   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66550   Dali::PanGesture *arg2 = 0 ;
66551
66552   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66553   arg2 = (Dali::PanGesture *)jarg2;
66554   if (!arg2) {
66555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
66556     return ;
66557   }
66558   {
66559     try {
66560       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
66561     } catch (std::out_of_range& e) {
66562       {
66563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66564       };
66565     } catch (std::exception& e) {
66566       {
66567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66568       };
66569     } catch (Dali::DaliException e) {
66570       {
66571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66572       };
66573     } catch (...) {
66574       {
66575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66576       };
66577     }
66578   }
66579
66580 }
66581
66582
66583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
66584   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66585   Dali::TapGesture *arg2 = 0 ;
66586
66587   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66588   arg2 = (Dali::TapGesture *)jarg2;
66589   if (!arg2) {
66590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66591     return ;
66592   }
66593   {
66594     try {
66595       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
66596     } catch (std::out_of_range& e) {
66597       {
66598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66599       };
66600     } catch (std::exception& e) {
66601       {
66602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66603       };
66604     } catch (Dali::DaliException e) {
66605       {
66606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66607       };
66608     } catch (...) {
66609       {
66610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66611       };
66612     }
66613   }
66614
66615 }
66616
66617
66618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66619   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66620   Dali::TapGesture *arg2 = 0 ;
66621
66622   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66623   arg2 = (Dali::TapGesture *)jarg2;
66624   if (!arg2) {
66625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
66626     return ;
66627   }
66628   {
66629     try {
66630       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
66631     } catch (std::out_of_range& e) {
66632       {
66633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66634       };
66635     } catch (std::exception& e) {
66636       {
66637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66638       };
66639     } catch (Dali::DaliException e) {
66640       {
66641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66642       };
66643     } catch (...) {
66644       {
66645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66646       };
66647     }
66648   }
66649
66650 }
66651
66652
66653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
66654   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66655   Dali::LongPressGesture *arg2 = 0 ;
66656
66657   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66658   arg2 = (Dali::LongPressGesture *)jarg2;
66659   if (!arg2) {
66660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66661     return ;
66662   }
66663   {
66664     try {
66665       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
66666     } catch (std::out_of_range& e) {
66667       {
66668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66669       };
66670     } catch (std::exception& e) {
66671       {
66672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66673       };
66674     } catch (Dali::DaliException e) {
66675       {
66676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66677       };
66678     } catch (...) {
66679       {
66680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66681       };
66682     }
66683   }
66684
66685 }
66686
66687
66688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
66689   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66690   Dali::LongPressGesture *arg2 = 0 ;
66691
66692   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66693   arg2 = (Dali::LongPressGesture *)jarg2;
66694   if (!arg2) {
66695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
66696     return ;
66697   }
66698   {
66699     try {
66700       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
66701     } catch (std::out_of_range& e) {
66702       {
66703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66704       };
66705     } catch (std::exception& e) {
66706       {
66707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66708       };
66709     } catch (Dali::DaliException e) {
66710       {
66711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66712       };
66713     } catch (...) {
66714       {
66715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66716       };
66717     }
66718   }
66719
66720 }
66721
66722
66723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
66724   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66725   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66726   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66727
66728   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66729   arg2 = (Dali::SlotObserver *)jarg2;
66730   arg3 = (Dali::CallbackBase *)jarg3;
66731   {
66732     try {
66733       (arg1)->SignalConnected(arg2,arg3);
66734     } catch (std::out_of_range& e) {
66735       {
66736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66737       };
66738     } catch (std::exception& e) {
66739       {
66740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66741       };
66742     } catch (Dali::DaliException e) {
66743       {
66744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66745       };
66746     } catch (...) {
66747       {
66748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66749       };
66750     }
66751   }
66752
66753 }
66754
66755
66756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66757   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66758   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66759   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66760
66761   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66762   arg2 = (Dali::SlotObserver *)jarg2;
66763   arg3 = (Dali::CallbackBase *)jarg3;
66764   {
66765     try {
66766       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
66767     } catch (std::out_of_range& e) {
66768       {
66769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66770       };
66771     } catch (std::exception& e) {
66772       {
66773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66774       };
66775     } catch (Dali::DaliException e) {
66776       {
66777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66778       };
66779     } catch (...) {
66780       {
66781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66782       };
66783     }
66784   }
66785
66786 }
66787
66788
66789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
66790   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66791   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66792   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66793
66794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66795   arg2 = (Dali::SlotObserver *)jarg2;
66796   arg3 = (Dali::CallbackBase *)jarg3;
66797   {
66798     try {
66799       (arg1)->SignalDisconnected(arg2,arg3);
66800     } catch (std::out_of_range& e) {
66801       {
66802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66803       };
66804     } catch (std::exception& e) {
66805       {
66806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66807       };
66808     } catch (Dali::DaliException e) {
66809       {
66810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66811       };
66812     } catch (...) {
66813       {
66814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66815       };
66816     }
66817   }
66818
66819 }
66820
66821
66822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
66823   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
66824   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
66825   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
66826
66827   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66828   arg2 = (Dali::SlotObserver *)jarg2;
66829   arg3 = (Dali::CallbackBase *)jarg3;
66830   {
66831     try {
66832       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
66833     } catch (std::out_of_range& e) {
66834       {
66835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66836       };
66837     } catch (std::exception& e) {
66838       {
66839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66840       };
66841     } catch (Dali::DaliException e) {
66842       {
66843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66844       };
66845     } catch (...) {
66846       {
66847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66848       };
66849     }
66850   }
66851
66852 }
66853
66854
66855 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) {
66856   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
66857   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
66858   if (director) {
66859     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);
66860   }
66861 }
66862
66863
66864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
66865   void * jresult ;
66866   Dali::Toolkit::Control *arg1 = 0 ;
66867   Dali::Toolkit::Internal::Control *result = 0 ;
66868
66869   arg1 = (Dali::Toolkit::Control *)jarg1;
66870   if (!arg1) {
66871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66872     return 0;
66873   }
66874   {
66875     try {
66876       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
66877     } catch (std::out_of_range& e) {
66878       {
66879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66880       };
66881     } catch (std::exception& e) {
66882       {
66883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66884       };
66885     } catch (Dali::DaliException e) {
66886       {
66887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66888       };
66889     } catch (...) {
66890       {
66891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66892       };
66893     }
66894   }
66895
66896   jresult = (void *)result;
66897   return jresult;
66898 }
66899
66900
66901 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
66902   int jresult ;
66903   int result;
66904
66905   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
66906   jresult = (int)result;
66907   return jresult;
66908 }
66909
66910
66911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_COLOR_get() {
66912   int jresult ;
66913   int result;
66914
66915   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_COLOR;
66916   jresult = (int)result;
66917   return jresult;
66918 }
66919
66920
66921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_IMAGE_get() {
66922   int jresult ;
66923   int result;
66924
66925   result = (int)Dali::Toolkit::Control::Property::BACKGROUND_IMAGE;
66926   jresult = (int)result;
66927   return jresult;
66928 }
66929
66930
66931 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
66932   int jresult ;
66933   int result;
66934
66935   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
66936   jresult = (int)result;
66937   return jresult;
66938 }
66939
66940
66941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
66942   int jresult ;
66943   int result;
66944
66945   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
66946   jresult = (int)result;
66947   return jresult;
66948 }
66949
66950 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
66951   int jresult ;
66952   int result;
66953
66954   result = (int)Dali::Toolkit::Control::Property::MARGIN;
66955   jresult = (int)result;
66956   return jresult;
66957 }
66958
66959
66960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
66961   int jresult ;
66962   int result;
66963
66964   result = (int)Dali::Toolkit::Control::Property::PADDING;
66965   jresult = (int)result;
66966   return jresult;
66967 }
66968
66969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
66970   void * jresult ;
66971   Dali::Toolkit::Control::Property *result = 0 ;
66972
66973   {
66974     try {
66975       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
66976     } catch (std::out_of_range& e) {
66977       {
66978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66979       };
66980     } catch (std::exception& e) {
66981       {
66982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66983       };
66984     } catch (Dali::DaliException e) {
66985       {
66986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66987       };
66988     } catch (...) {
66989       {
66990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66991       };
66992     }
66993   }
66994
66995   jresult = (void *)result;
66996   return jresult;
66997 }
66998
66999
67000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
67001   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
67002
67003   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
67004   {
67005     try {
67006       delete arg1;
67007     } catch (std::out_of_range& e) {
67008       {
67009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67010       };
67011     } catch (std::exception& e) {
67012       {
67013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67014       };
67015     } catch (Dali::DaliException e) {
67016       {
67017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67018       };
67019     } catch (...) {
67020       {
67021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67022       };
67023     }
67024   }
67025
67026 }
67027
67028
67029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
67030   void * jresult ;
67031   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
67032
67033   {
67034     try {
67035       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
67036     } catch (std::out_of_range& e) {
67037       {
67038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67039       };
67040     } catch (std::exception& e) {
67041       {
67042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67043       };
67044     } catch (Dali::DaliException e) {
67045       {
67046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67047       };
67048     } catch (...) {
67049       {
67050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67051       };
67052     }
67053   }
67054
67055   jresult = (void *)result;
67056   return jresult;
67057 }
67058
67059
67060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
67061   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
67062
67063   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
67064   {
67065     try {
67066       delete arg1;
67067     } catch (std::out_of_range& e) {
67068       {
67069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67070       };
67071     } catch (std::exception& e) {
67072       {
67073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67074       };
67075     } catch (Dali::DaliException e) {
67076       {
67077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67078       };
67079     } catch (...) {
67080       {
67081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67082       };
67083     }
67084   }
67085
67086 }
67087
67088
67089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
67090   void * jresult ;
67091   Dali::Toolkit::Control result;
67092
67093   {
67094     try {
67095       result = Dali::Toolkit::Control::New();
67096     } catch (std::out_of_range& e) {
67097       {
67098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67099       };
67100     } catch (std::exception& e) {
67101       {
67102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67103       };
67104     } catch (Dali::DaliException e) {
67105       {
67106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67107       };
67108     } catch (...) {
67109       {
67110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67111       };
67112     }
67113   }
67114
67115   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67116   return jresult;
67117 }
67118
67119
67120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
67121   void * jresult ;
67122   Dali::Toolkit::Control *result = 0 ;
67123
67124   {
67125     try {
67126       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
67127     } catch (std::out_of_range& e) {
67128       {
67129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67130       };
67131     } catch (std::exception& e) {
67132       {
67133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67134       };
67135     } catch (Dali::DaliException e) {
67136       {
67137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67138       };
67139     } catch (...) {
67140       {
67141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67142       };
67143     }
67144   }
67145
67146   jresult = (void *)result;
67147   return jresult;
67148 }
67149
67150
67151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
67152   void * jresult ;
67153   Dali::Toolkit::Control *arg1 = 0 ;
67154   Dali::Toolkit::Control *result = 0 ;
67155
67156   arg1 = (Dali::Toolkit::Control *)jarg1;
67157   if (!arg1) {
67158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67159     return 0;
67160   }
67161   {
67162     try {
67163       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
67164     } catch (std::out_of_range& e) {
67165       {
67166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67167       };
67168     } catch (std::exception& e) {
67169       {
67170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67171       };
67172     } catch (Dali::DaliException e) {
67173       {
67174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67175       };
67176     } catch (...) {
67177       {
67178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67179       };
67180     }
67181   }
67182
67183   jresult = (void *)result;
67184   return jresult;
67185 }
67186
67187
67188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
67189   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67190
67191   arg1 = (Dali::Toolkit::Control *)jarg1;
67192   {
67193     try {
67194       delete arg1;
67195     } catch (std::out_of_range& e) {
67196       {
67197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67198       };
67199     } catch (std::exception& e) {
67200       {
67201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67202       };
67203     } catch (Dali::DaliException e) {
67204       {
67205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67206       };
67207     } catch (...) {
67208       {
67209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67210       };
67211     }
67212   }
67213
67214 }
67215
67216
67217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
67218   void * jresult ;
67219   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67220   Dali::Toolkit::Control *arg2 = 0 ;
67221   Dali::Toolkit::Control *result = 0 ;
67222
67223   arg1 = (Dali::Toolkit::Control *)jarg1;
67224   arg2 = (Dali::Toolkit::Control *)jarg2;
67225   if (!arg2) {
67226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
67227     return 0;
67228   }
67229   {
67230     try {
67231       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
67232     } catch (std::out_of_range& e) {
67233       {
67234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67235       };
67236     } catch (std::exception& e) {
67237       {
67238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67239       };
67240     } catch (Dali::DaliException e) {
67241       {
67242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67243       };
67244     } catch (...) {
67245       {
67246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67247       };
67248     }
67249   }
67250
67251   jresult = (void *)result;
67252   return jresult;
67253 }
67254
67255
67256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
67257   void * jresult ;
67258   Dali::BaseHandle arg1 ;
67259   Dali::BaseHandle *argp1 ;
67260   Dali::Toolkit::Control result;
67261
67262   argp1 = (Dali::BaseHandle *)jarg1;
67263   if (!argp1) {
67264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67265     return 0;
67266   }
67267   arg1 = *argp1;
67268   {
67269     try {
67270       result = Dali::Toolkit::Control::DownCast(arg1);
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 = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
67291   return jresult;
67292 }
67293
67294
67295 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
67296   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67297
67298   arg1 = (Dali::Toolkit::Control *)jarg1;
67299   {
67300     try {
67301       (arg1)->SetKeyInputFocus();
67302     } catch (std::out_of_range& e) {
67303       {
67304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67305       };
67306     } catch (std::exception& e) {
67307       {
67308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67309       };
67310     } catch (Dali::DaliException e) {
67311       {
67312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67313       };
67314     } catch (...) {
67315       {
67316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67317       };
67318     }
67319   }
67320
67321 }
67322
67323
67324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
67325   unsigned int jresult ;
67326   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67327   bool result;
67328
67329   arg1 = (Dali::Toolkit::Control *)jarg1;
67330   {
67331     try {
67332       result = (bool)(arg1)->HasKeyInputFocus();
67333     } catch (std::out_of_range& e) {
67334       {
67335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67336       };
67337     } catch (std::exception& e) {
67338       {
67339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67340       };
67341     } catch (Dali::DaliException e) {
67342       {
67343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67344       };
67345     } catch (...) {
67346       {
67347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67348       };
67349     }
67350   }
67351
67352   jresult = result;
67353   return jresult;
67354 }
67355
67356
67357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
67358   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67359
67360   arg1 = (Dali::Toolkit::Control *)jarg1;
67361   {
67362     try {
67363       (arg1)->ClearKeyInputFocus();
67364     } catch (std::out_of_range& e) {
67365       {
67366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67367       };
67368     } catch (std::exception& e) {
67369       {
67370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67371       };
67372     } catch (Dali::DaliException e) {
67373       {
67374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67375       };
67376     } catch (...) {
67377       {
67378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67379       };
67380     }
67381   }
67382
67383 }
67384
67385
67386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
67387   void * jresult ;
67388   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67389   Dali::PinchGestureDetector result;
67390
67391   arg1 = (Dali::Toolkit::Control *)jarg1;
67392   {
67393     try {
67394       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
67395     } catch (std::out_of_range& e) {
67396       {
67397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67398       };
67399     } catch (std::exception& e) {
67400       {
67401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67402       };
67403     } catch (Dali::DaliException e) {
67404       {
67405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67406       };
67407     } catch (...) {
67408       {
67409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67410       };
67411     }
67412   }
67413
67414   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
67415   return jresult;
67416 }
67417
67418
67419 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
67420   void * jresult ;
67421   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67422   Dali::PanGestureDetector result;
67423
67424   arg1 = (Dali::Toolkit::Control *)jarg1;
67425   {
67426     try {
67427       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
67428     } catch (std::out_of_range& e) {
67429       {
67430         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67431       };
67432     } catch (std::exception& e) {
67433       {
67434         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67435       };
67436     } catch (Dali::DaliException e) {
67437       {
67438         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67439       };
67440     } catch (...) {
67441       {
67442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67443       };
67444     }
67445   }
67446
67447   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
67448   return jresult;
67449 }
67450
67451
67452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
67453   void * jresult ;
67454   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67455   Dali::TapGestureDetector result;
67456
67457   arg1 = (Dali::Toolkit::Control *)jarg1;
67458   {
67459     try {
67460       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
67461     } catch (std::out_of_range& e) {
67462       {
67463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67464       };
67465     } catch (std::exception& e) {
67466       {
67467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67468       };
67469     } catch (Dali::DaliException e) {
67470       {
67471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67472       };
67473     } catch (...) {
67474       {
67475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67476       };
67477     }
67478   }
67479
67480   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
67481   return jresult;
67482 }
67483
67484
67485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
67486   void * jresult ;
67487   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67488   Dali::LongPressGestureDetector result;
67489
67490   arg1 = (Dali::Toolkit::Control *)jarg1;
67491   {
67492     try {
67493       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
67494     } catch (std::out_of_range& e) {
67495       {
67496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67497       };
67498     } catch (std::exception& e) {
67499       {
67500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67501       };
67502     } catch (Dali::DaliException e) {
67503       {
67504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67505       };
67506     } catch (...) {
67507       {
67508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67509       };
67510     }
67511   }
67512
67513   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
67514   return jresult;
67515 }
67516
67517
67518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
67519   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67520   std::string *arg2 = 0 ;
67521
67522   arg1 = (Dali::Toolkit::Control *)jarg1;
67523   if (!jarg2) {
67524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67525     return ;
67526   }
67527   std::string arg2_str(jarg2);
67528   arg2 = &arg2_str;
67529   {
67530     try {
67531       (arg1)->SetStyleName((std::string const &)*arg2);
67532     } catch (std::out_of_range& e) {
67533       {
67534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67535       };
67536     } catch (std::exception& e) {
67537       {
67538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67539       };
67540     } catch (Dali::DaliException e) {
67541       {
67542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67543       };
67544     } catch (...) {
67545       {
67546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67547       };
67548     }
67549   }
67550
67551
67552   //argout typemap for const std::string&
67553
67554 }
67555
67556
67557 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
67558   char * jresult ;
67559   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67560   std::string *result = 0 ;
67561
67562   arg1 = (Dali::Toolkit::Control *)jarg1;
67563   {
67564     try {
67565       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
67566     } catch (std::out_of_range& e) {
67567       {
67568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67569       };
67570     } catch (std::exception& e) {
67571       {
67572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67573       };
67574     } catch (Dali::DaliException e) {
67575       {
67576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67577       };
67578     } catch (...) {
67579       {
67580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67581       };
67582     }
67583   }
67584
67585   jresult = SWIG_csharp_string_callback(result->c_str());
67586   return jresult;
67587 }
67588
67589
67590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
67591   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67592   Dali::Vector4 *arg2 = 0 ;
67593
67594   arg1 = (Dali::Toolkit::Control *)jarg1;
67595   arg2 = (Dali::Vector4 *)jarg2;
67596   if (!arg2) {
67597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
67598     return ;
67599   }
67600   {
67601     try {
67602       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
67603     } catch (std::out_of_range& e) {
67604       {
67605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67606       };
67607     } catch (std::exception& e) {
67608       {
67609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67610       };
67611     } catch (Dali::DaliException e) {
67612       {
67613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67614       };
67615     } catch (...) {
67616       {
67617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67618       };
67619     }
67620   }
67621
67622 }
67623
67624
67625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetBackgroundColor(void * jarg1) {
67626   void * jresult ;
67627   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67628   Dali::Vector4 result;
67629
67630   arg1 = (Dali::Toolkit::Control *)jarg1;
67631   {
67632     try {
67633       result = ((Dali::Toolkit::Control const *)arg1)->GetBackgroundColor();
67634     } catch (std::out_of_range& e) {
67635       {
67636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67637       };
67638     } catch (std::exception& e) {
67639       {
67640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67641       };
67642     } catch (Dali::DaliException e) {
67643       {
67644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67645       };
67646     } catch (...) {
67647       {
67648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67649       };
67650     }
67651   }
67652
67653   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
67654   return jresult;
67655 }
67656
67657
67658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundImage(void * jarg1, void * jarg2) {
67659   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67660   Dali::Image arg2 ;
67661   Dali::Image *argp2 ;
67662
67663   arg1 = (Dali::Toolkit::Control *)jarg1;
67664   argp2 = (Dali::Image *)jarg2;
67665   if (!argp2) {
67666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
67667     return ;
67668   }
67669   arg2 = *argp2;
67670   {
67671     try {
67672       (arg1)->SetBackgroundImage(arg2);
67673     } catch (std::out_of_range& e) {
67674       {
67675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67676       };
67677     } catch (std::exception& e) {
67678       {
67679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67680       };
67681     } catch (Dali::DaliException e) {
67682       {
67683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67684       };
67685     } catch (...) {
67686       {
67687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67688       };
67689     }
67690   }
67691
67692 }
67693
67694
67695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
67696   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67697
67698   arg1 = (Dali::Toolkit::Control *)jarg1;
67699   {
67700     try {
67701       (arg1)->ClearBackground();
67702     } catch (std::out_of_range& e) {
67703       {
67704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67705       };
67706     } catch (std::exception& e) {
67707       {
67708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67709       };
67710     } catch (Dali::DaliException e) {
67711       {
67712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67713       };
67714     } catch (...) {
67715       {
67716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67717       };
67718     }
67719   }
67720
67721 }
67722
67723
67724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
67725   void * jresult ;
67726   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67727   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
67728
67729   arg1 = (Dali::Toolkit::Control *)jarg1;
67730   {
67731     try {
67732       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
67733     } catch (std::out_of_range& e) {
67734       {
67735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67736       };
67737     } catch (std::exception& e) {
67738       {
67739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67740       };
67741     } catch (Dali::DaliException e) {
67742       {
67743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67744       };
67745     } catch (...) {
67746       {
67747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67748       };
67749     }
67750   }
67751
67752   jresult = (void *)result;
67753   return jresult;
67754 }
67755
67756
67757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
67758   void * jresult ;
67759   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67760   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67761
67762   arg1 = (Dali::Toolkit::Control *)jarg1;
67763   {
67764     try {
67765       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
67766     } catch (std::out_of_range& e) {
67767       {
67768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67769       };
67770     } catch (std::exception& e) {
67771       {
67772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67773       };
67774     } catch (Dali::DaliException e) {
67775       {
67776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67777       };
67778     } catch (...) {
67779       {
67780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67781       };
67782     }
67783   }
67784
67785   jresult = (void *)result;
67786   return jresult;
67787 }
67788
67789
67790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
67791   void * jresult ;
67792   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67793   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
67794
67795   arg1 = (Dali::Toolkit::Control *)jarg1;
67796   {
67797     try {
67798       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
67799     } catch (std::out_of_range& e) {
67800       {
67801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67802       };
67803     } catch (std::exception& e) {
67804       {
67805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67806       };
67807     } catch (Dali::DaliException e) {
67808       {
67809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67810       };
67811     } catch (...) {
67812       {
67813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67814       };
67815     }
67816   }
67817
67818   jresult = (void *)result;
67819   return jresult;
67820 }
67821
67822
67823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
67824   void * jresult ;
67825   Dali::Toolkit::Internal::Control *arg1 = 0 ;
67826   Dali::Toolkit::Control *result = 0 ;
67827
67828   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
67829   if (!arg1) {
67830     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
67831     return 0;
67832   }
67833   {
67834     try {
67835       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
67836     } catch (std::out_of_range& e) {
67837       {
67838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67839       };
67840     } catch (std::exception& e) {
67841       {
67842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67843       };
67844     } catch (Dali::DaliException e) {
67845       {
67846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67847       };
67848     } catch (...) {
67849       {
67850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67851       };
67852     }
67853   }
67854
67855   jresult = (void *)result;
67856   return jresult;
67857 }
67858
67859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
67860 {
67861   int jresult;
67862   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67863   arg1 = (Dali::Toolkit::Control *)jarg1;
67864
67865   if (!arg1) {
67866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67867     return 0;
67868   }
67869
67870   Dali::Property::Index arg2 = 0 ;
67871   arg2 = (Dali::Property::Index)jarg2;
67872
67873   Toolkit::Visual::ResourceStatus result;
67874   {
67875     try {
67876       result = arg1->GetVisualResourceStatus(arg2);
67877     } catch (std::out_of_range& e) {
67878       {
67879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67880       };
67881     } catch (std::exception& e) {
67882       {
67883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67884       };
67885     } catch (...) {
67886       {
67887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67888       };
67889     }
67890   }
67891   jresult = (int)(result);
67892   return jresult;
67893 }
67894
67895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
67896 {
67897   void * jresult;
67898   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
67899   arg1 = (Dali::Toolkit::Control *)jarg1;
67900
67901   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
67902
67903   Dali::Toolkit::TransitionData *arg2 = 0 ;
67904   Dali::Animation result;
67905
67906   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
67907   if (!arg2) {
67908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
67909     return 0;
67910   }
67911   {
67912     try {
67913       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
67914     } catch (std::out_of_range& e) {
67915       {
67916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67917       };
67918     } catch (std::exception& e) {
67919       {
67920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67921       };
67922     } catch (Dali::DaliException e) {
67923       {
67924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67925       };
67926     } catch (...) {
67927       {
67928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67929       };
67930     }
67931   }
67932
67933   jresult = new Dali::Animation((const Dali::Animation &)result);
67934   return jresult;
67935 }
67936
67937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
67938 {
67939   Dali::Toolkit::Control arg1;
67940   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
67941
67942   if (!argp1) {
67943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67944   }
67945   arg1 = *argp1;
67946
67947   Dali::Property::Index arg2 = 0 ;
67948   arg2 = (Dali::Property::Index)jarg2;
67949
67950   Dali::Property::Index arg3 = 0 ;
67951   arg3 = (Dali::Property::Index)jarg3;
67952
67953   Dali::Property::Value arg4;
67954   arg4 = (Dali::Property::Value *)jarg4;
67955
67956   {
67957     try {
67958       DevelControl::DoAction(arg1, arg2, arg3, arg4);
67959     } catch (std::out_of_range& e) {
67960       {
67961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67962       };
67963     } catch (std::exception& e) {
67964       {
67965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67966       };
67967     } catch (...) {
67968       {
67969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67970       };
67971     }
67972   }
67973
67974
67975 }
67976
67977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
67978   void * jresult ;
67979   Dali::Toolkit::Control *arg1 = 0 ;
67980   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
67981
67982   arg1 = (Dali::Toolkit::Control *)jarg1;
67983   if (!arg1) {
67984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
67985     return 0;
67986   }
67987   {
67988     try {
67989       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
67990     } catch (std::out_of_range& e) {
67991       {
67992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67993       };
67994     } catch (std::exception& e) {
67995       {
67996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67997       };
67998     } catch (Dali::DaliException e) {
67999       {
68000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68001       };
68002     } catch (...) {
68003       {
68004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68005       };
68006     }
68007   }
68008
68009   jresult = (void *)result;
68010   return jresult;
68011 }
68012
68013
68014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
68015   unsigned int jresult ;
68016   Dali::Toolkit::Control *arg1 = 0 ;
68017   bool result;
68018
68019   arg1 = (Dali::Toolkit::Control *)jarg1;
68020   if (!arg1) {
68021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
68022     return 0;
68023   }
68024   {
68025     try {
68026       result = (bool)arg1->IsResourceReady();
68027     } catch (std::out_of_range& e) {
68028       {
68029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68030       };
68031     } catch (std::exception& e) {
68032       {
68033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68034       };
68035     } catch (Dali::DaliException e) {
68036       {
68037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68038       };
68039     } catch (...) {
68040       {
68041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68042       };
68043     }
68044   }
68045
68046   jresult = result;
68047   return jresult;
68048 }
68049
68050
68051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
68052   void * jresult ;
68053   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
68054
68055   {
68056     try {
68057       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
68058     } catch (std::out_of_range& e) {
68059       {
68060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68061       };
68062     } catch (std::exception& e) {
68063       {
68064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68065       };
68066     } catch (Dali::DaliException e) {
68067       {
68068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68069       };
68070     } catch (...) {
68071       {
68072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68073       };
68074     }
68075   }
68076
68077   jresult = (void *)result;
68078   return jresult;
68079 }
68080
68081
68082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
68083   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68084
68085   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68086   {
68087     try {
68088       delete arg1;
68089     } catch (std::out_of_range& e) {
68090       {
68091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68092       };
68093     } catch (std::exception& e) {
68094       {
68095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68096       };
68097     } catch (Dali::DaliException e) {
68098       {
68099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68100       };
68101     } catch (...) {
68102       {
68103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68104       };
68105     }
68106   }
68107
68108 }
68109
68110
68111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
68112   void * jresult ;
68113   Dali::Toolkit::KeyInputFocusManager result;
68114
68115   {
68116     try {
68117       result = Dali::Toolkit::KeyInputFocusManager::Get();
68118     } catch (std::out_of_range& e) {
68119       {
68120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68121       };
68122     } catch (std::exception& e) {
68123       {
68124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68125       };
68126     } catch (Dali::DaliException e) {
68127       {
68128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68129       };
68130     } catch (...) {
68131       {
68132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68133       };
68134     }
68135   }
68136
68137   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
68138   return jresult;
68139 }
68140
68141
68142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
68143   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68144   Dali::Toolkit::Control arg2 ;
68145   Dali::Toolkit::Control *argp2 ;
68146
68147   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68148   argp2 = (Dali::Toolkit::Control *)jarg2;
68149   if (!argp2) {
68150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68151     return ;
68152   }
68153   arg2 = *argp2;
68154   {
68155     try {
68156       (arg1)->SetFocus(arg2);
68157     } catch (std::out_of_range& e) {
68158       {
68159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68160       };
68161     } catch (std::exception& e) {
68162       {
68163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68164       };
68165     } catch (Dali::DaliException e) {
68166       {
68167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68168       };
68169     } catch (...) {
68170       {
68171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68172       };
68173     }
68174   }
68175
68176 }
68177
68178
68179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
68180   void * jresult ;
68181   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68182   Dali::Toolkit::Control result;
68183
68184   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68185   {
68186     try {
68187       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
68188     } catch (std::out_of_range& e) {
68189       {
68190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68191       };
68192     } catch (std::exception& e) {
68193       {
68194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68195       };
68196     } catch (Dali::DaliException e) {
68197       {
68198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68199       };
68200     } catch (...) {
68201       {
68202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68203       };
68204     }
68205   }
68206
68207   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
68208   return jresult;
68209 }
68210
68211
68212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
68213   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68214   Dali::Toolkit::Control arg2 ;
68215   Dali::Toolkit::Control *argp2 ;
68216
68217   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68218   argp2 = (Dali::Toolkit::Control *)jarg2;
68219   if (!argp2) {
68220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
68221     return ;
68222   }
68223   arg2 = *argp2;
68224   {
68225     try {
68226       (arg1)->RemoveFocus(arg2);
68227     } catch (std::out_of_range& e) {
68228       {
68229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68230       };
68231     } catch (std::exception& e) {
68232       {
68233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68234       };
68235     } catch (Dali::DaliException e) {
68236       {
68237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68238       };
68239     } catch (...) {
68240       {
68241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68242       };
68243     }
68244   }
68245
68246 }
68247
68248
68249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
68250   void * jresult ;
68251   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
68252   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
68253
68254   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
68255   {
68256     try {
68257       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
68258     } catch (std::out_of_range& e) {
68259       {
68260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68261       };
68262     } catch (std::exception& e) {
68263       {
68264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68265       };
68266     } catch (Dali::DaliException e) {
68267       {
68268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68269       };
68270     } catch (...) {
68271       {
68272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68273       };
68274     }
68275   }
68276
68277   jresult = (void *)result;
68278   return jresult;
68279 }
68280
68281
68282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
68283   void * jresult ;
68284   Dali::Toolkit::Alignment::Padding *result = 0 ;
68285
68286   {
68287     try {
68288       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
68289     } catch (std::out_of_range& e) {
68290       {
68291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68292       };
68293     } catch (std::exception& e) {
68294       {
68295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68296       };
68297     } catch (Dali::DaliException e) {
68298       {
68299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68300       };
68301     } catch (...) {
68302       {
68303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68304       };
68305     }
68306   }
68307
68308   jresult = (void *)result;
68309   return jresult;
68310 }
68311
68312
68313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
68314   void * jresult ;
68315   float arg1 ;
68316   float arg2 ;
68317   float arg3 ;
68318   float arg4 ;
68319   Dali::Toolkit::Alignment::Padding *result = 0 ;
68320
68321   arg1 = (float)jarg1;
68322   arg2 = (float)jarg2;
68323   arg3 = (float)jarg3;
68324   arg4 = (float)jarg4;
68325   {
68326     try {
68327       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
68328     } catch (std::out_of_range& e) {
68329       {
68330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68331       };
68332     } catch (std::exception& e) {
68333       {
68334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68335       };
68336     } catch (Dali::DaliException e) {
68337       {
68338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68339       };
68340     } catch (...) {
68341       {
68342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68343       };
68344     }
68345   }
68346
68347   jresult = (void *)result;
68348   return jresult;
68349 }
68350
68351
68352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
68353   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68354   float arg2 ;
68355
68356   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68357   arg2 = (float)jarg2;
68358   if (arg1) (arg1)->left = arg2;
68359 }
68360
68361
68362 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
68363   float jresult ;
68364   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68365   float result;
68366
68367   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68368   result = (float) ((arg1)->left);
68369   jresult = result;
68370   return jresult;
68371 }
68372
68373
68374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
68375   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68376   float arg2 ;
68377
68378   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68379   arg2 = (float)jarg2;
68380   if (arg1) (arg1)->right = arg2;
68381 }
68382
68383
68384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
68385   float jresult ;
68386   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68387   float result;
68388
68389   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68390   result = (float) ((arg1)->right);
68391   jresult = result;
68392   return jresult;
68393 }
68394
68395
68396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
68397   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68398   float arg2 ;
68399
68400   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68401   arg2 = (float)jarg2;
68402   if (arg1) (arg1)->top = arg2;
68403 }
68404
68405
68406 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
68407   float jresult ;
68408   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68409   float result;
68410
68411   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68412   result = (float) ((arg1)->top);
68413   jresult = result;
68414   return jresult;
68415 }
68416
68417
68418 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
68419   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68420   float arg2 ;
68421
68422   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68423   arg2 = (float)jarg2;
68424   if (arg1) (arg1)->bottom = arg2;
68425 }
68426
68427
68428 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
68429   float jresult ;
68430   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68431   float result;
68432
68433   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68434   result = (float) ((arg1)->bottom);
68435   jresult = result;
68436   return jresult;
68437 }
68438
68439
68440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
68441   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
68442
68443   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
68444   {
68445     try {
68446       delete arg1;
68447     } catch (std::out_of_range& e) {
68448       {
68449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68450       };
68451     } catch (std::exception& e) {
68452       {
68453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68454       };
68455     } catch (Dali::DaliException e) {
68456       {
68457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68458       };
68459     } catch (...) {
68460       {
68461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68462       };
68463     }
68464   }
68465
68466 }
68467
68468
68469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
68470   void * jresult ;
68471   Dali::Toolkit::Alignment *result = 0 ;
68472
68473   {
68474     try {
68475       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
68476     } catch (std::out_of_range& e) {
68477       {
68478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68479       };
68480     } catch (std::exception& e) {
68481       {
68482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68483       };
68484     } catch (Dali::DaliException e) {
68485       {
68486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68487       };
68488     } catch (...) {
68489       {
68490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68491       };
68492     }
68493   }
68494
68495   jresult = (void *)result;
68496   return jresult;
68497 }
68498
68499
68500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
68501   void * jresult ;
68502   Dali::Toolkit::Alignment::Type arg1 ;
68503   Dali::Toolkit::Alignment::Type arg2 ;
68504   Dali::Toolkit::Alignment result;
68505
68506   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68507   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68508   {
68509     try {
68510       result = Dali::Toolkit::Alignment::New(arg1,arg2);
68511     } catch (std::out_of_range& e) {
68512       {
68513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68514       };
68515     } catch (std::exception& e) {
68516       {
68517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68518       };
68519     } catch (Dali::DaliException e) {
68520       {
68521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68522       };
68523     } catch (...) {
68524       {
68525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68526       };
68527     }
68528   }
68529
68530   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68531   return jresult;
68532 }
68533
68534
68535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
68536   void * jresult ;
68537   Dali::Toolkit::Alignment::Type arg1 ;
68538   Dali::Toolkit::Alignment result;
68539
68540   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
68541   {
68542     try {
68543       result = Dali::Toolkit::Alignment::New(arg1);
68544     } catch (std::out_of_range& e) {
68545       {
68546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68547       };
68548     } catch (std::exception& e) {
68549       {
68550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68551       };
68552     } catch (Dali::DaliException e) {
68553       {
68554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68555       };
68556     } catch (...) {
68557       {
68558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68559       };
68560     }
68561   }
68562
68563   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68564   return jresult;
68565 }
68566
68567
68568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
68569   void * jresult ;
68570   Dali::Toolkit::Alignment result;
68571
68572   {
68573     try {
68574       result = Dali::Toolkit::Alignment::New();
68575     } catch (std::out_of_range& e) {
68576       {
68577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68578       };
68579     } catch (std::exception& e) {
68580       {
68581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68582       };
68583     } catch (Dali::DaliException e) {
68584       {
68585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68586       };
68587     } catch (...) {
68588       {
68589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68590       };
68591     }
68592   }
68593
68594   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68595   return jresult;
68596 }
68597
68598
68599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
68600   void * jresult ;
68601   Dali::Toolkit::Alignment *arg1 = 0 ;
68602   Dali::Toolkit::Alignment *result = 0 ;
68603
68604   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68605   if (!arg1) {
68606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68607     return 0;
68608   }
68609   {
68610     try {
68611       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
68612     } catch (std::out_of_range& e) {
68613       {
68614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68615       };
68616     } catch (std::exception& e) {
68617       {
68618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68619       };
68620     } catch (Dali::DaliException e) {
68621       {
68622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68623       };
68624     } catch (...) {
68625       {
68626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68627       };
68628     }
68629   }
68630
68631   jresult = (void *)result;
68632   return jresult;
68633 }
68634
68635
68636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
68637   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68638
68639   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68640   {
68641     try {
68642       delete arg1;
68643     } catch (std::out_of_range& e) {
68644       {
68645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68646       };
68647     } catch (std::exception& e) {
68648       {
68649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68650       };
68651     } catch (Dali::DaliException e) {
68652       {
68653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68654       };
68655     } catch (...) {
68656       {
68657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68658       };
68659     }
68660   }
68661
68662 }
68663
68664
68665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
68666   void * jresult ;
68667   Dali::BaseHandle arg1 ;
68668   Dali::BaseHandle *argp1 ;
68669   Dali::Toolkit::Alignment result;
68670
68671   argp1 = (Dali::BaseHandle *)jarg1;
68672   if (!argp1) {
68673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68674     return 0;
68675   }
68676   arg1 = *argp1;
68677   {
68678     try {
68679       result = Dali::Toolkit::Alignment::DownCast(arg1);
68680     } catch (std::out_of_range& e) {
68681       {
68682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68683       };
68684     } catch (std::exception& e) {
68685       {
68686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68687       };
68688     } catch (Dali::DaliException e) {
68689       {
68690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68691       };
68692     } catch (...) {
68693       {
68694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68695       };
68696     }
68697   }
68698
68699   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
68700   return jresult;
68701 }
68702
68703
68704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
68705   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68706   Dali::Toolkit::Alignment::Type arg2 ;
68707
68708   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68709   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
68710   {
68711     try {
68712       (arg1)->SetAlignmentType(arg2);
68713     } catch (std::out_of_range& e) {
68714       {
68715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68716       };
68717     } catch (std::exception& e) {
68718       {
68719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68720       };
68721     } catch (Dali::DaliException e) {
68722       {
68723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68724       };
68725     } catch (...) {
68726       {
68727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68728       };
68729     }
68730   }
68731
68732 }
68733
68734
68735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
68736   int jresult ;
68737   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68738   Dali::Toolkit::Alignment::Type result;
68739
68740   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68741   {
68742     try {
68743       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
68744     } catch (std::out_of_range& e) {
68745       {
68746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68747       };
68748     } catch (std::exception& e) {
68749       {
68750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68751       };
68752     } catch (Dali::DaliException e) {
68753       {
68754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68755       };
68756     } catch (...) {
68757       {
68758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68759       };
68760     }
68761   }
68762
68763   jresult = (int)result;
68764   return jresult;
68765 }
68766
68767
68768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
68769   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68770   Dali::Toolkit::Alignment::Scaling arg2 ;
68771
68772   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68773   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
68774   {
68775     try {
68776       (arg1)->SetScaling(arg2);
68777     } catch (std::out_of_range& e) {
68778       {
68779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68780       };
68781     } catch (std::exception& e) {
68782       {
68783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68784       };
68785     } catch (Dali::DaliException e) {
68786       {
68787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68788       };
68789     } catch (...) {
68790       {
68791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68792       };
68793     }
68794   }
68795
68796 }
68797
68798
68799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
68800   int jresult ;
68801   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68802   Dali::Toolkit::Alignment::Scaling result;
68803
68804   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68805   {
68806     try {
68807       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
68808     } catch (std::out_of_range& e) {
68809       {
68810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68811       };
68812     } catch (std::exception& e) {
68813       {
68814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68815       };
68816     } catch (Dali::DaliException e) {
68817       {
68818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68819       };
68820     } catch (...) {
68821       {
68822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68823       };
68824     }
68825   }
68826
68827   jresult = (int)result;
68828   return jresult;
68829 }
68830
68831
68832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
68833   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68834   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
68835
68836   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68837   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
68838   if (!arg2) {
68839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
68840     return ;
68841   }
68842   {
68843     try {
68844       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
68845     } catch (std::out_of_range& e) {
68846       {
68847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68848       };
68849     } catch (std::exception& e) {
68850       {
68851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68852       };
68853     } catch (Dali::DaliException e) {
68854       {
68855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68856       };
68857     } catch (...) {
68858       {
68859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68860       };
68861     }
68862   }
68863
68864 }
68865
68866
68867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
68868   void * jresult ;
68869   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68870   Dali::Toolkit::Alignment::Padding *result = 0 ;
68871
68872   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68873   {
68874     try {
68875       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
68876     } catch (std::out_of_range& e) {
68877       {
68878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68879       };
68880     } catch (std::exception& e) {
68881       {
68882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68883       };
68884     } catch (Dali::DaliException e) {
68885       {
68886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68887       };
68888     } catch (...) {
68889       {
68890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68891       };
68892     }
68893   }
68894
68895   jresult = (void *)result;
68896   return jresult;
68897 }
68898
68899
68900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
68901   void * jresult ;
68902   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
68903   Dali::Toolkit::Alignment *arg2 = 0 ;
68904   Dali::Toolkit::Alignment *result = 0 ;
68905
68906   arg1 = (Dali::Toolkit::Alignment *)jarg1;
68907   arg2 = (Dali::Toolkit::Alignment *)jarg2;
68908   if (!arg2) {
68909     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
68910     return 0;
68911   }
68912   {
68913     try {
68914       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
68915     } catch (std::out_of_range& e) {
68916       {
68917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68918       };
68919     } catch (std::exception& e) {
68920       {
68921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68922       };
68923     } catch (Dali::DaliException e) {
68924       {
68925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68926       };
68927     } catch (...) {
68928       {
68929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68930       };
68931     }
68932   }
68933
68934   jresult = (void *)result;
68935   return jresult;
68936 }
68937
68938
68939 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
68940   int jresult ;
68941   int result;
68942
68943   result = (int)Dali::Toolkit::Button::Property::DISABLED;
68944   jresult = (int)result;
68945   return jresult;
68946 }
68947
68948
68949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
68950   int jresult ;
68951   int result;
68952
68953   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
68954   jresult = (int)result;
68955   return jresult;
68956 }
68957
68958
68959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
68960   int jresult ;
68961   int result;
68962
68963   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
68964   jresult = (int)result;
68965   return jresult;
68966 }
68967
68968
68969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
68970   int jresult ;
68971   int result;
68972
68973   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
68974   jresult = (int)result;
68975   return jresult;
68976 }
68977
68978
68979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
68980   int jresult ;
68981   int result;
68982
68983   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
68984   jresult = (int)result;
68985   return jresult;
68986 }
68987
68988
68989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
68990   int jresult ;
68991   int result;
68992
68993   result = (int)Dali::Toolkit::Button::Property::SELECTED;
68994   jresult = (int)result;
68995   return jresult;
68996 }
68997
68998
68999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_UNSELECTED_COLOR_get() {
69000   int jresult ;
69001   int result;
69002
69003   result = (int)Dali::Toolkit::Button::Property::UNSELECTED_COLOR;
69004   jresult = (int)result;
69005   return jresult;
69006 }
69007
69008
69009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_COLOR_get() {
69010   int jresult ;
69011   int result;
69012
69013   result = (int)Dali::Toolkit::Button::Property::SELECTED_COLOR;
69014   jresult = (int)result;
69015   return jresult;
69016 }
69017
69018
69019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
69020   int jresult ;
69021   int result;
69022
69023   result = (int)Dali::Toolkit::Button::Property::LABEL;
69024   jresult = (int)result;
69025   return jresult;
69026 }
69027
69028
69029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_TEXT_get() {
69030   int jresult ;
69031   int result;
69032
69033   result = (int)Dali::Toolkit::Button::Property::LABEL_TEXT;
69034   jresult = (int)result;
69035   return jresult;
69036 }
69037
69038
69039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
69040   void * jresult ;
69041   Dali::Toolkit::Button::Property *result = 0 ;
69042
69043   {
69044     try {
69045       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
69046     } catch (std::out_of_range& e) {
69047       {
69048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69049       };
69050     } catch (std::exception& e) {
69051       {
69052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69053       };
69054     } catch (Dali::DaliException e) {
69055       {
69056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69057       };
69058     } catch (...) {
69059       {
69060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69061       };
69062     }
69063   }
69064
69065   jresult = (void *)result;
69066   return jresult;
69067 }
69068
69069
69070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
69071   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
69072
69073   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
69074   {
69075     try {
69076       delete arg1;
69077     } catch (std::out_of_range& e) {
69078       {
69079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69080       };
69081     } catch (std::exception& e) {
69082       {
69083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69084       };
69085     } catch (Dali::DaliException e) {
69086       {
69087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69088       };
69089     } catch (...) {
69090       {
69091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69092       };
69093     }
69094   }
69095
69096 }
69097
69098
69099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
69100   void * jresult ;
69101   Dali::Toolkit::Button *result = 0 ;
69102
69103   {
69104     try {
69105       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
69106     } catch (std::out_of_range& e) {
69107       {
69108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69109       };
69110     } catch (std::exception& e) {
69111       {
69112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69113       };
69114     } catch (Dali::DaliException e) {
69115       {
69116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69117       };
69118     } catch (...) {
69119       {
69120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69121       };
69122     }
69123   }
69124
69125   jresult = (void *)result;
69126   return jresult;
69127 }
69128
69129
69130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
69131   void * jresult ;
69132   Dali::Toolkit::Button *arg1 = 0 ;
69133   Dali::Toolkit::Button *result = 0 ;
69134
69135   arg1 = (Dali::Toolkit::Button *)jarg1;
69136   if (!arg1) {
69137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69138     return 0;
69139   }
69140   {
69141     try {
69142       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
69143     } catch (std::out_of_range& e) {
69144       {
69145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69146       };
69147     } catch (std::exception& e) {
69148       {
69149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69150       };
69151     } catch (Dali::DaliException e) {
69152       {
69153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69154       };
69155     } catch (...) {
69156       {
69157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69158       };
69159     }
69160   }
69161
69162   jresult = (void *)result;
69163   return jresult;
69164 }
69165
69166
69167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
69168   void * jresult ;
69169   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69170   Dali::Toolkit::Button *arg2 = 0 ;
69171   Dali::Toolkit::Button *result = 0 ;
69172
69173   arg1 = (Dali::Toolkit::Button *)jarg1;
69174   arg2 = (Dali::Toolkit::Button *)jarg2;
69175   if (!arg2) {
69176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
69177     return 0;
69178   }
69179   {
69180     try {
69181       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
69182     } catch (std::out_of_range& e) {
69183       {
69184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69185       };
69186     } catch (std::exception& e) {
69187       {
69188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69189       };
69190     } catch (Dali::DaliException e) {
69191       {
69192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69193       };
69194     } catch (...) {
69195       {
69196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69197       };
69198     }
69199   }
69200
69201   jresult = (void *)result;
69202   return jresult;
69203 }
69204
69205
69206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
69207   void * jresult ;
69208   Dali::BaseHandle arg1 ;
69209   Dali::BaseHandle *argp1 ;
69210   Dali::Toolkit::Button result;
69211
69212   argp1 = (Dali::BaseHandle *)jarg1;
69213   if (!argp1) {
69214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69215     return 0;
69216   }
69217   arg1 = *argp1;
69218   {
69219     try {
69220       result = Dali::Toolkit::Button::DownCast(arg1);
69221     } catch (std::out_of_range& e) {
69222       {
69223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69224       };
69225     } catch (std::exception& e) {
69226       {
69227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69228       };
69229     } catch (Dali::DaliException e) {
69230       {
69231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69232       };
69233     } catch (...) {
69234       {
69235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69236       };
69237     }
69238   }
69239
69240   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
69241   return jresult;
69242 }
69243
69244
69245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
69246   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69247
69248   arg1 = (Dali::Toolkit::Button *)jarg1;
69249   {
69250     try {
69251       delete arg1;
69252     } catch (std::out_of_range& e) {
69253       {
69254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69255       };
69256     } catch (std::exception& e) {
69257       {
69258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69259       };
69260     } catch (Dali::DaliException e) {
69261       {
69262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69263       };
69264     } catch (...) {
69265       {
69266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69267       };
69268     }
69269   }
69270
69271 }
69272
69273
69274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsDisabled(void * jarg1) {
69275   unsigned int jresult ;
69276   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69277   bool result;
69278
69279   arg1 = (Dali::Toolkit::Button *)jarg1;
69280   {
69281     try {
69282       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsDisabled();
69283     } catch (std::out_of_range& e) {
69284       {
69285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69286       };
69287     } catch (std::exception& e) {
69288       {
69289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69290       };
69291     } catch (Dali::DaliException e) {
69292       {
69293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69294       };
69295     } catch (...) {
69296       {
69297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69298       };
69299     }
69300   }
69301
69302   jresult = result;
69303   return jresult;
69304 }
69305
69306
69307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsAutoRepeating(void * jarg1) {
69308   unsigned int jresult ;
69309   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69310   bool result;
69311
69312   arg1 = (Dali::Toolkit::Button *)jarg1;
69313   {
69314     try {
69315       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsAutoRepeating();
69316     } catch (std::out_of_range& e) {
69317       {
69318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69319       };
69320     } catch (std::exception& e) {
69321       {
69322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69323       };
69324     } catch (Dali::DaliException e) {
69325       {
69326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69327       };
69328     } catch (...) {
69329       {
69330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69331       };
69332     }
69333   }
69334
69335   jresult = result;
69336   return jresult;
69337 }
69338
69339
69340 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetInitialAutoRepeatingDelay(void * jarg1) {
69341   float jresult ;
69342   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69343   float result;
69344
69345   arg1 = (Dali::Toolkit::Button *)jarg1;
69346   {
69347     try {
69348       result = (float)((Dali::Toolkit::Button const *)arg1)->GetInitialAutoRepeatingDelay();
69349     } catch (std::out_of_range& e) {
69350       {
69351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69352       };
69353     } catch (std::exception& e) {
69354       {
69355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69356       };
69357     } catch (Dali::DaliException e) {
69358       {
69359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69360       };
69361     } catch (...) {
69362       {
69363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69364       };
69365     }
69366   }
69367
69368   jresult = result;
69369   return jresult;
69370 }
69371
69372
69373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetNextAutoRepeatingDelay(void * jarg1) {
69374   float jresult ;
69375   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69376   float result;
69377
69378   arg1 = (Dali::Toolkit::Button *)jarg1;
69379   {
69380     try {
69381       result = (float)((Dali::Toolkit::Button const *)arg1)->GetNextAutoRepeatingDelay();
69382     } catch (std::out_of_range& e) {
69383       {
69384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69385       };
69386     } catch (std::exception& e) {
69387       {
69388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69389       };
69390     } catch (Dali::DaliException e) {
69391       {
69392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69393       };
69394     } catch (...) {
69395       {
69396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69397       };
69398     }
69399   }
69400
69401   jresult = result;
69402   return jresult;
69403 }
69404
69405
69406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsTogglableButton(void * jarg1) {
69407   unsigned int jresult ;
69408   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69409   bool result;
69410
69411   arg1 = (Dali::Toolkit::Button *)jarg1;
69412   {
69413     try {
69414       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsTogglableButton();
69415     } catch (std::out_of_range& e) {
69416       {
69417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69418       };
69419     } catch (std::exception& e) {
69420       {
69421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69422       };
69423     } catch (Dali::DaliException e) {
69424       {
69425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69426       };
69427     } catch (...) {
69428       {
69429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69430       };
69431     }
69432   }
69433
69434   jresult = result;
69435   return jresult;
69436 }
69437
69438
69439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Button_IsSelected(void * jarg1) {
69440   unsigned int jresult ;
69441   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69442   bool result;
69443
69444   arg1 = (Dali::Toolkit::Button *)jarg1;
69445   {
69446     try {
69447       result = (bool)((Dali::Toolkit::Button const *)arg1)->IsSelected();
69448     } catch (std::out_of_range& e) {
69449       {
69450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69451       };
69452     } catch (std::exception& e) {
69453       {
69454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69455       };
69456     } catch (Dali::DaliException e) {
69457       {
69458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69459       };
69460     } catch (...) {
69461       {
69462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69463       };
69464     }
69465   }
69466
69467   jresult = result;
69468   return jresult;
69469 }
69470
69471
69472 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Button_GetAnimationTime(void * jarg1) {
69473   float jresult ;
69474   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69475   float result;
69476
69477   arg1 = (Dali::Toolkit::Button *)jarg1;
69478   {
69479     try {
69480       result = (float)((Dali::Toolkit::Button const *)arg1)->GetAnimationTime();
69481     } catch (std::out_of_range& e) {
69482       {
69483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69484       };
69485     } catch (std::exception& e) {
69486       {
69487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69488       };
69489     } catch (Dali::DaliException e) {
69490       {
69491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69492       };
69493     } catch (...) {
69494       {
69495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69496       };
69497     }
69498   }
69499
69500   jresult = result;
69501   return jresult;
69502 }
69503
69504
69505 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Button_GetLabelText(void * jarg1) {
69506   char * jresult ;
69507   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69508   std::string result;
69509
69510   arg1 = (Dali::Toolkit::Button *)jarg1;
69511   {
69512     try {
69513       result = ((Dali::Toolkit::Button const *)arg1)->GetLabelText();
69514     } catch (std::out_of_range& e) {
69515       {
69516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69517       };
69518     } catch (std::exception& e) {
69519       {
69520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69521       };
69522     } catch (Dali::DaliException e) {
69523       {
69524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69525       };
69526     } catch (...) {
69527       {
69528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69529       };
69530     }
69531   }
69532
69533   jresult = SWIG_csharp_string_callback((&result)->c_str());
69534   return jresult;
69535 }
69536
69537
69538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetLabel(void * jarg1, void * jarg2) {
69539   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69540   Dali::Actor arg2 ;
69541   Dali::Actor *argp2 ;
69542
69543   arg1 = (Dali::Toolkit::Button *)jarg1;
69544   argp2 = (Dali::Actor *)jarg2;
69545   if (!argp2) {
69546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
69547     return ;
69548   }
69549   arg2 = *argp2;
69550   {
69551     try {
69552       (arg1)->SetLabel(arg2);
69553     } catch (std::out_of_range& e) {
69554       {
69555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69556       };
69557     } catch (std::exception& e) {
69558       {
69559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69560       };
69561     } catch (Dali::DaliException e) {
69562       {
69563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69564       };
69565     } catch (...) {
69566       {
69567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69568       };
69569     }
69570   }
69571
69572 }
69573
69574
69575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetButtonImage(void * jarg1, void * jarg2) {
69576   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69577   Dali::Image arg2 ;
69578   Dali::Image *argp2 ;
69579
69580   arg1 = (Dali::Toolkit::Button *)jarg1;
69581   argp2 = (Dali::Image *)jarg2;
69582   if (!argp2) {
69583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69584     return ;
69585   }
69586   arg2 = *argp2;
69587   {
69588     try {
69589       (arg1)->SetButtonImage(arg2);
69590     } catch (std::out_of_range& e) {
69591       {
69592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69593       };
69594     } catch (std::exception& e) {
69595       {
69596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69597       };
69598     } catch (Dali::DaliException e) {
69599       {
69600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69601       };
69602     } catch (...) {
69603       {
69604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69605       };
69606     }
69607   }
69608
69609 }
69610
69611
69612 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Button_SetSelectedImage(void * jarg1, void * jarg2) {
69613   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69614   Dali::Image arg2 ;
69615   Dali::Image *argp2 ;
69616
69617   arg1 = (Dali::Toolkit::Button *)jarg1;
69618   argp2 = (Dali::Image *)jarg2;
69619   if (!argp2) {
69620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69621     return ;
69622   }
69623   arg2 = *argp2;
69624   {
69625     try {
69626       (arg1)->SetSelectedImage(arg2);
69627     } catch (std::out_of_range& e) {
69628       {
69629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69630       };
69631     } catch (std::exception& e) {
69632       {
69633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69634       };
69635     } catch (Dali::DaliException e) {
69636       {
69637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69638       };
69639     } catch (...) {
69640       {
69641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69642       };
69643     }
69644   }
69645
69646 }
69647
69648
69649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetButtonImage(void * jarg1) {
69650   void * jresult ;
69651   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69652   Dali::Actor result;
69653
69654   arg1 = (Dali::Toolkit::Button *)jarg1;
69655   {
69656     try {
69657       result = ((Dali::Toolkit::Button const *)arg1)->GetButtonImage();
69658     } catch (std::out_of_range& e) {
69659       {
69660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69661       };
69662     } catch (std::exception& e) {
69663       {
69664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69665       };
69666     } catch (Dali::DaliException e) {
69667       {
69668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69669       };
69670     } catch (...) {
69671       {
69672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69673       };
69674     }
69675   }
69676
69677   jresult = new Dali::Actor((const Dali::Actor &)result);
69678   return jresult;
69679 }
69680
69681
69682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_GetSelectedImage(void * jarg1) {
69683   void * jresult ;
69684   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69685   Dali::Actor result;
69686
69687   arg1 = (Dali::Toolkit::Button *)jarg1;
69688   {
69689     try {
69690       result = ((Dali::Toolkit::Button const *)arg1)->GetSelectedImage();
69691     } catch (std::out_of_range& e) {
69692       {
69693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69694       };
69695     } catch (std::exception& e) {
69696       {
69697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69698       };
69699     } catch (Dali::DaliException e) {
69700       {
69701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69702       };
69703     } catch (...) {
69704       {
69705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69706       };
69707     }
69708   }
69709
69710   jresult = new Dali::Actor((const Dali::Actor &)result);
69711   return jresult;
69712 }
69713
69714
69715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
69716   void * jresult ;
69717   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69718   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69719
69720   arg1 = (Dali::Toolkit::Button *)jarg1;
69721   {
69722     try {
69723       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
69724     } catch (std::out_of_range& e) {
69725       {
69726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69727       };
69728     } catch (std::exception& e) {
69729       {
69730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69731       };
69732     } catch (Dali::DaliException e) {
69733       {
69734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69735       };
69736     } catch (...) {
69737       {
69738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69739       };
69740     }
69741   }
69742
69743   jresult = (void *)result;
69744   return jresult;
69745 }
69746
69747
69748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
69749   void * jresult ;
69750   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69751   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69752
69753   arg1 = (Dali::Toolkit::Button *)jarg1;
69754   {
69755     try {
69756       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
69757     } catch (std::out_of_range& e) {
69758       {
69759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69760       };
69761     } catch (std::exception& e) {
69762       {
69763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69764       };
69765     } catch (Dali::DaliException e) {
69766       {
69767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69768       };
69769     } catch (...) {
69770       {
69771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69772       };
69773     }
69774   }
69775
69776   jresult = (void *)result;
69777   return jresult;
69778 }
69779
69780
69781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
69782   void * jresult ;
69783   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69784   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69785
69786   arg1 = (Dali::Toolkit::Button *)jarg1;
69787   {
69788     try {
69789       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
69790     } catch (std::out_of_range& e) {
69791       {
69792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69793       };
69794     } catch (std::exception& e) {
69795       {
69796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69797       };
69798     } catch (Dali::DaliException e) {
69799       {
69800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69801       };
69802     } catch (...) {
69803       {
69804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69805       };
69806     }
69807   }
69808
69809   jresult = (void *)result;
69810   return jresult;
69811 }
69812
69813
69814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
69815   void * jresult ;
69816   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
69817   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
69818
69819   arg1 = (Dali::Toolkit::Button *)jarg1;
69820   {
69821     try {
69822       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
69823     } catch (std::out_of_range& e) {
69824       {
69825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69826       };
69827     } catch (std::exception& e) {
69828       {
69829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69830       };
69831     } catch (Dali::DaliException e) {
69832       {
69833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69834       };
69835     } catch (...) {
69836       {
69837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69838       };
69839     }
69840   }
69841
69842   jresult = (void *)result;
69843   return jresult;
69844 }
69845
69846
69847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
69848   void * jresult ;
69849   Dali::Toolkit::CheckBoxButton *result = 0 ;
69850
69851   {
69852     try {
69853       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
69854     } catch (std::out_of_range& e) {
69855       {
69856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69857       };
69858     } catch (std::exception& e) {
69859       {
69860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69861       };
69862     } catch (Dali::DaliException e) {
69863       {
69864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69865       };
69866     } catch (...) {
69867       {
69868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69869       };
69870     }
69871   }
69872
69873   jresult = (void *)result;
69874   return jresult;
69875 }
69876
69877
69878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
69879   void * jresult ;
69880   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
69881   Dali::Toolkit::CheckBoxButton *result = 0 ;
69882
69883   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69884   if (!arg1) {
69885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69886     return 0;
69887   }
69888   {
69889     try {
69890       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
69891     } catch (std::out_of_range& e) {
69892       {
69893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69894       };
69895     } catch (std::exception& e) {
69896       {
69897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69898       };
69899     } catch (Dali::DaliException e) {
69900       {
69901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69902       };
69903     } catch (...) {
69904       {
69905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69906       };
69907     }
69908   }
69909
69910   jresult = (void *)result;
69911   return jresult;
69912 }
69913
69914
69915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
69916   void * jresult ;
69917   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69918   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
69919   Dali::Toolkit::CheckBoxButton *result = 0 ;
69920
69921   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69922   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
69923   if (!arg2) {
69924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
69925     return 0;
69926   }
69927   {
69928     try {
69929       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
69930     } catch (std::out_of_range& e) {
69931       {
69932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69933       };
69934     } catch (std::exception& e) {
69935       {
69936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69937       };
69938     } catch (Dali::DaliException e) {
69939       {
69940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69941       };
69942     } catch (...) {
69943       {
69944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69945       };
69946     }
69947   }
69948
69949   jresult = (void *)result;
69950   return jresult;
69951 }
69952
69953
69954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
69955   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
69956
69957   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
69958   {
69959     try {
69960       delete arg1;
69961     } catch (std::out_of_range& e) {
69962       {
69963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69964       };
69965     } catch (std::exception& e) {
69966       {
69967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69968       };
69969     } catch (Dali::DaliException e) {
69970       {
69971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69972       };
69973     } catch (...) {
69974       {
69975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69976       };
69977     }
69978   }
69979
69980 }
69981
69982
69983 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
69984   void * jresult ;
69985   Dali::Toolkit::CheckBoxButton result;
69986
69987   {
69988     try {
69989       result = Dali::Toolkit::CheckBoxButton::New();
69990     } catch (std::out_of_range& e) {
69991       {
69992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69993       };
69994     } catch (std::exception& e) {
69995       {
69996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69997       };
69998     } catch (Dali::DaliException e) {
69999       {
70000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70001       };
70002     } catch (...) {
70003       {
70004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70005       };
70006     }
70007   }
70008
70009   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70010   return jresult;
70011 }
70012
70013
70014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
70015   void * jresult ;
70016   Dali::BaseHandle arg1 ;
70017   Dali::BaseHandle *argp1 ;
70018   Dali::Toolkit::CheckBoxButton result;
70019
70020   argp1 = (Dali::BaseHandle *)jarg1;
70021   if (!argp1) {
70022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70023     return 0;
70024   }
70025   arg1 = *argp1;
70026   {
70027     try {
70028       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
70029     } catch (std::out_of_range& e) {
70030       {
70031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70032       };
70033     } catch (std::exception& e) {
70034       {
70035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70036       };
70037     } catch (Dali::DaliException e) {
70038       {
70039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70040       };
70041     } catch (...) {
70042       {
70043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70044       };
70045     }
70046   }
70047
70048   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
70049   return jresult;
70050 }
70051
70052
70053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
70054   int jresult ;
70055   int result;
70056
70057   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
70058   jresult = (int)result;
70059   return jresult;
70060 }
70061
70062
70063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
70064   int jresult ;
70065   int result;
70066
70067   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
70068   jresult = (int)result;
70069   return jresult;
70070 }
70071
70072
70073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
70074   int jresult ;
70075   int result;
70076
70077   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
70078   jresult = (int)result;
70079   return jresult;
70080 }
70081
70082
70083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
70084   int jresult ;
70085   int result;
70086
70087   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
70088   jresult = (int)result;
70089   return jresult;
70090 }
70091
70092
70093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
70094   int jresult ;
70095   int result;
70096
70097   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
70098   jresult = (int)result;
70099   return jresult;
70100 }
70101
70102
70103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
70104   void * jresult ;
70105   Dali::Toolkit::PushButton::Property *result = 0 ;
70106
70107   {
70108     try {
70109       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
70110     } catch (std::out_of_range& e) {
70111       {
70112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70113       };
70114     } catch (std::exception& e) {
70115       {
70116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70117       };
70118     } catch (Dali::DaliException e) {
70119       {
70120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70121       };
70122     } catch (...) {
70123       {
70124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70125       };
70126     }
70127   }
70128
70129   jresult = (void *)result;
70130   return jresult;
70131 }
70132
70133
70134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
70135   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
70136
70137   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
70138   {
70139     try {
70140       delete arg1;
70141     } catch (std::out_of_range& e) {
70142       {
70143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70144       };
70145     } catch (std::exception& e) {
70146       {
70147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70148       };
70149     } catch (Dali::DaliException e) {
70150       {
70151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70152       };
70153     } catch (...) {
70154       {
70155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70156       };
70157     }
70158   }
70159
70160 }
70161
70162
70163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
70164   void * jresult ;
70165   Dali::Toolkit::PushButton *result = 0 ;
70166
70167   {
70168     try {
70169       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
70170     } catch (std::out_of_range& e) {
70171       {
70172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70173       };
70174     } catch (std::exception& e) {
70175       {
70176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70177       };
70178     } catch (Dali::DaliException e) {
70179       {
70180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70181       };
70182     } catch (...) {
70183       {
70184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70185       };
70186     }
70187   }
70188
70189   jresult = (void *)result;
70190   return jresult;
70191 }
70192
70193
70194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
70195   void * jresult ;
70196   Dali::Toolkit::PushButton *arg1 = 0 ;
70197   Dali::Toolkit::PushButton *result = 0 ;
70198
70199   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70200   if (!arg1) {
70201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70202     return 0;
70203   }
70204   {
70205     try {
70206       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
70207     } catch (std::out_of_range& e) {
70208       {
70209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70210       };
70211     } catch (std::exception& e) {
70212       {
70213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70214       };
70215     } catch (Dali::DaliException e) {
70216       {
70217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70218       };
70219     } catch (...) {
70220       {
70221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70222       };
70223     }
70224   }
70225
70226   jresult = (void *)result;
70227   return jresult;
70228 }
70229
70230
70231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
70232   void * jresult ;
70233   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70234   Dali::Toolkit::PushButton *arg2 = 0 ;
70235   Dali::Toolkit::PushButton *result = 0 ;
70236
70237   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70238   arg2 = (Dali::Toolkit::PushButton *)jarg2;
70239   if (!arg2) {
70240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
70241     return 0;
70242   }
70243   {
70244     try {
70245       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
70246     } catch (std::out_of_range& e) {
70247       {
70248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70249       };
70250     } catch (std::exception& e) {
70251       {
70252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70253       };
70254     } catch (Dali::DaliException e) {
70255       {
70256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70257       };
70258     } catch (...) {
70259       {
70260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70261       };
70262     }
70263   }
70264
70265   jresult = (void *)result;
70266   return jresult;
70267 }
70268
70269
70270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
70271   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70272
70273   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70274   {
70275     try {
70276       delete arg1;
70277     } catch (std::out_of_range& e) {
70278       {
70279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70280       };
70281     } catch (std::exception& e) {
70282       {
70283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70284       };
70285     } catch (Dali::DaliException e) {
70286       {
70287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70288       };
70289     } catch (...) {
70290       {
70291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70292       };
70293     }
70294   }
70295
70296 }
70297
70298
70299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
70300   void * jresult ;
70301   Dali::Toolkit::PushButton result;
70302
70303   {
70304     try {
70305       result = Dali::Toolkit::PushButton::New();
70306     } catch (std::out_of_range& e) {
70307       {
70308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70309       };
70310     } catch (std::exception& e) {
70311       {
70312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70313       };
70314     } catch (Dali::DaliException e) {
70315       {
70316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70317       };
70318     } catch (...) {
70319       {
70320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70321       };
70322     }
70323   }
70324
70325   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70326   return jresult;
70327 }
70328
70329
70330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
70331   void * jresult ;
70332   Dali::BaseHandle arg1 ;
70333   Dali::BaseHandle *argp1 ;
70334   Dali::Toolkit::PushButton result;
70335
70336   argp1 = (Dali::BaseHandle *)jarg1;
70337   if (!argp1) {
70338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70339     return 0;
70340   }
70341   arg1 = *argp1;
70342   {
70343     try {
70344       result = Dali::Toolkit::PushButton::DownCast(arg1);
70345     } catch (std::out_of_range& e) {
70346       {
70347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70348       };
70349     } catch (std::exception& e) {
70350       {
70351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70352       };
70353     } catch (Dali::DaliException e) {
70354       {
70355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70356       };
70357     } catch (...) {
70358       {
70359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70360       };
70361     }
70362   }
70363
70364   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
70365   return jresult;
70366 }
70367
70368
70369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_0_0(void * jarg1, void * jarg2) {
70370   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70371   Dali::Image arg2 ;
70372   Dali::Image *argp2 ;
70373
70374   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70375   argp2 = (Dali::Image *)jarg2;
70376   if (!argp2) {
70377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70378     return ;
70379   }
70380   arg2 = *argp2;
70381   {
70382     try {
70383       (arg1)->SetButtonImage(arg2);
70384     } catch (std::out_of_range& e) {
70385       {
70386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70387       };
70388     } catch (std::exception& e) {
70389       {
70390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70391       };
70392     } catch (Dali::DaliException e) {
70393       {
70394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70395       };
70396     } catch (...) {
70397       {
70398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70399       };
70400     }
70401   }
70402
70403 }
70404
70405
70406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetButtonImage__SWIG_1(void * jarg1, void * jarg2) {
70407   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70408   Dali::Actor arg2 ;
70409   Dali::Actor *argp2 ;
70410
70411   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70412   argp2 = (Dali::Actor *)jarg2;
70413   if (!argp2) {
70414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70415     return ;
70416   }
70417   arg2 = *argp2;
70418   {
70419     try {
70420       (arg1)->SetButtonImage(arg2);
70421     } catch (std::out_of_range& e) {
70422       {
70423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70424       };
70425     } catch (std::exception& e) {
70426       {
70427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70428       };
70429     } catch (Dali::DaliException e) {
70430       {
70431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70432       };
70433     } catch (...) {
70434       {
70435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70436       };
70437     }
70438   }
70439
70440 }
70441
70442
70443 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetBackgroundImage(void * jarg1, void * jarg2) {
70444   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70445   Dali::Actor arg2 ;
70446   Dali::Actor *argp2 ;
70447
70448   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70449   argp2 = (Dali::Actor *)jarg2;
70450   if (!argp2) {
70451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70452     return ;
70453   }
70454   arg2 = *argp2;
70455   {
70456     try {
70457       (arg1)->SetBackgroundImage(arg2);
70458     } catch (std::out_of_range& e) {
70459       {
70460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70461       };
70462     } catch (std::exception& e) {
70463       {
70464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70465       };
70466     } catch (Dali::DaliException e) {
70467       {
70468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70469       };
70470     } catch (...) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70473       };
70474     }
70475   }
70476
70477 }
70478
70479
70480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_0_0(void * jarg1, void * jarg2) {
70481   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70482   Dali::Image arg2 ;
70483   Dali::Image *argp2 ;
70484
70485   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70486   argp2 = (Dali::Image *)jarg2;
70487   if (!argp2) {
70488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
70489     return ;
70490   }
70491   arg2 = *argp2;
70492   {
70493     try {
70494       (arg1)->SetSelectedImage(arg2);
70495     } catch (std::out_of_range& e) {
70496       {
70497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70498       };
70499     } catch (std::exception& e) {
70500       {
70501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70502       };
70503     } catch (Dali::DaliException e) {
70504       {
70505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70506       };
70507     } catch (...) {
70508       {
70509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70510       };
70511     }
70512   }
70513
70514 }
70515
70516
70517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedImage__SWIG_1(void * jarg1, void * jarg2) {
70518   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70519   Dali::Actor arg2 ;
70520   Dali::Actor *argp2 ;
70521
70522   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70523   argp2 = (Dali::Actor *)jarg2;
70524   if (!argp2) {
70525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70526     return ;
70527   }
70528   arg2 = *argp2;
70529   {
70530     try {
70531       (arg1)->SetSelectedImage(arg2);
70532     } catch (std::out_of_range& e) {
70533       {
70534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70535       };
70536     } catch (std::exception& e) {
70537       {
70538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70539       };
70540     } catch (Dali::DaliException e) {
70541       {
70542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70543       };
70544     } catch (...) {
70545       {
70546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70547       };
70548     }
70549   }
70550
70551 }
70552
70553
70554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetSelectedBackgroundImage(void * jarg1, void * jarg2) {
70555   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70556   Dali::Actor arg2 ;
70557   Dali::Actor *argp2 ;
70558
70559   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70560   argp2 = (Dali::Actor *)jarg2;
70561   if (!argp2) {
70562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70563     return ;
70564   }
70565   arg2 = *argp2;
70566   {
70567     try {
70568       (arg1)->SetSelectedBackgroundImage(arg2);
70569     } catch (std::out_of_range& e) {
70570       {
70571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70572       };
70573     } catch (std::exception& e) {
70574       {
70575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70576       };
70577     } catch (Dali::DaliException e) {
70578       {
70579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70580       };
70581     } catch (...) {
70582       {
70583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70584       };
70585     }
70586   }
70587
70588 }
70589
70590
70591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledBackgroundImage(void * jarg1, void * jarg2) {
70592   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70593   Dali::Actor arg2 ;
70594   Dali::Actor *argp2 ;
70595
70596   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70597   argp2 = (Dali::Actor *)jarg2;
70598   if (!argp2) {
70599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70600     return ;
70601   }
70602   arg2 = *argp2;
70603   {
70604     try {
70605       (arg1)->SetDisabledBackgroundImage(arg2);
70606     } catch (std::out_of_range& e) {
70607       {
70608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70609       };
70610     } catch (std::exception& e) {
70611       {
70612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70613       };
70614     } catch (Dali::DaliException e) {
70615       {
70616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70617       };
70618     } catch (...) {
70619       {
70620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70621       };
70622     }
70623   }
70624
70625 }
70626
70627
70628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledImage(void * jarg1, void * jarg2) {
70629   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70630   Dali::Actor arg2 ;
70631   Dali::Actor *argp2 ;
70632
70633   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70634   argp2 = (Dali::Actor *)jarg2;
70635   if (!argp2) {
70636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70637     return ;
70638   }
70639   arg2 = *argp2;
70640   {
70641     try {
70642       (arg1)->SetDisabledImage(arg2);
70643     } catch (std::out_of_range& e) {
70644       {
70645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70646       };
70647     } catch (std::exception& e) {
70648       {
70649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70650       };
70651     } catch (Dali::DaliException e) {
70652       {
70653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70654       };
70655     } catch (...) {
70656       {
70657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70658       };
70659     }
70660   }
70661
70662 }
70663
70664
70665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PushButton_SetDisabledSelectedImage(void * jarg1, void * jarg2) {
70666   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
70667   Dali::Actor arg2 ;
70668   Dali::Actor *argp2 ;
70669
70670   arg1 = (Dali::Toolkit::PushButton *)jarg1;
70671   argp2 = (Dali::Actor *)jarg2;
70672   if (!argp2) {
70673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70674     return ;
70675   }
70676   arg2 = *argp2;
70677   {
70678     try {
70679       (arg1)->SetDisabledSelectedImage(arg2);
70680     } catch (std::out_of_range& e) {
70681       {
70682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70683       };
70684     } catch (std::exception& e) {
70685       {
70686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70687       };
70688     } catch (Dali::DaliException e) {
70689       {
70690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70691       };
70692     } catch (...) {
70693       {
70694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70695       };
70696     }
70697   }
70698
70699 }
70700
70701
70702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
70703   void * jresult ;
70704   Dali::Toolkit::RadioButton *result = 0 ;
70705
70706   {
70707     try {
70708       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
70709     } catch (std::out_of_range& e) {
70710       {
70711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70712       };
70713     } catch (std::exception& e) {
70714       {
70715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70716       };
70717     } catch (Dali::DaliException e) {
70718       {
70719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70720       };
70721     } catch (...) {
70722       {
70723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70724       };
70725     }
70726   }
70727
70728   jresult = (void *)result;
70729   return jresult;
70730 }
70731
70732
70733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
70734   void * jresult ;
70735   Dali::Toolkit::RadioButton *arg1 = 0 ;
70736   Dali::Toolkit::RadioButton *result = 0 ;
70737
70738   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70739   if (!arg1) {
70740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70741     return 0;
70742   }
70743   {
70744     try {
70745       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
70746     } catch (std::out_of_range& e) {
70747       {
70748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70749       };
70750     } catch (std::exception& e) {
70751       {
70752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70753       };
70754     } catch (Dali::DaliException e) {
70755       {
70756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70757       };
70758     } catch (...) {
70759       {
70760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70761       };
70762     }
70763   }
70764
70765   jresult = (void *)result;
70766   return jresult;
70767 }
70768
70769
70770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
70771   void * jresult ;
70772   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70773   Dali::Toolkit::RadioButton *arg2 = 0 ;
70774   Dali::Toolkit::RadioButton *result = 0 ;
70775
70776   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70777   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
70778   if (!arg2) {
70779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
70780     return 0;
70781   }
70782   {
70783     try {
70784       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
70785     } catch (std::out_of_range& e) {
70786       {
70787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70788       };
70789     } catch (std::exception& e) {
70790       {
70791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70792       };
70793     } catch (Dali::DaliException e) {
70794       {
70795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70796       };
70797     } catch (...) {
70798       {
70799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70800       };
70801     }
70802   }
70803
70804   jresult = (void *)result;
70805   return jresult;
70806 }
70807
70808
70809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
70810   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
70811
70812   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
70813   {
70814     try {
70815       delete arg1;
70816     } catch (std::out_of_range& e) {
70817       {
70818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70819       };
70820     } catch (std::exception& e) {
70821       {
70822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70823       };
70824     } catch (Dali::DaliException e) {
70825       {
70826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70827       };
70828     } catch (...) {
70829       {
70830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70831       };
70832     }
70833   }
70834
70835 }
70836
70837
70838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
70839   void * jresult ;
70840   Dali::Toolkit::RadioButton result;
70841
70842   {
70843     try {
70844       result = Dali::Toolkit::RadioButton::New();
70845     } catch (std::out_of_range& e) {
70846       {
70847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70848       };
70849     } catch (std::exception& e) {
70850       {
70851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70852       };
70853     } catch (Dali::DaliException e) {
70854       {
70855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70856       };
70857     } catch (...) {
70858       {
70859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70860       };
70861     }
70862   }
70863
70864   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70865   return jresult;
70866 }
70867
70868
70869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
70870   void * jresult ;
70871   std::string *arg1 = 0 ;
70872   Dali::Toolkit::RadioButton result;
70873
70874   if (!jarg1) {
70875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
70876     return 0;
70877   }
70878   std::string arg1_str(jarg1);
70879   arg1 = &arg1_str;
70880   {
70881     try {
70882       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
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
70904   //argout typemap for const std::string&
70905
70906   return jresult;
70907 }
70908
70909
70910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
70911   void * jresult ;
70912   Dali::BaseHandle arg1 ;
70913   Dali::BaseHandle *argp1 ;
70914   Dali::Toolkit::RadioButton result;
70915
70916   argp1 = (Dali::BaseHandle *)jarg1;
70917   if (!argp1) {
70918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70919     return 0;
70920   }
70921   arg1 = *argp1;
70922   {
70923     try {
70924       result = Dali::Toolkit::RadioButton::DownCast(arg1);
70925     } catch (std::out_of_range& e) {
70926       {
70927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70928       };
70929     } catch (std::exception& e) {
70930       {
70931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70932       };
70933     } catch (Dali::DaliException e) {
70934       {
70935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70936       };
70937     } catch (...) {
70938       {
70939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70940       };
70941     }
70942   }
70943
70944   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
70945   return jresult;
70946 }
70947
70948
70949 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
70950   int jresult ;
70951   int result;
70952
70953   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
70954   jresult = (int)result;
70955   return jresult;
70956 }
70957
70958
70959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
70960   int jresult ;
70961   int result;
70962
70963   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
70964   jresult = (int)result;
70965   return jresult;
70966 }
70967
70968
70969 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
70970   int jresult ;
70971   int result;
70972
70973   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
70974   jresult = (int)result;
70975   return jresult;
70976 }
70977
70978
70979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
70980   int jresult ;
70981   int result;
70982
70983   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
70984   jresult = (int)result;
70985   return jresult;
70986 }
70987
70988
70989 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
70990   int jresult ;
70991   int result;
70992
70993   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
70994   jresult = (int)result;
70995   return jresult;
70996 }
70997
70998
70999 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
71000   int jresult ;
71001   int result;
71002
71003   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
71004   jresult = (int)result;
71005   return jresult;
71006 }
71007
71008
71009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
71010   void * jresult ;
71011   Dali::Toolkit::FlexContainer::Property *result = 0 ;
71012
71013   {
71014     try {
71015       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
71016     } catch (std::out_of_range& e) {
71017       {
71018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71019       };
71020     } catch (std::exception& e) {
71021       {
71022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71023       };
71024     } catch (Dali::DaliException e) {
71025       {
71026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71027       };
71028     } catch (...) {
71029       {
71030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71031       };
71032     }
71033   }
71034
71035   jresult = (void *)result;
71036   return jresult;
71037 }
71038
71039
71040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
71041   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
71042
71043   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
71044   {
71045     try {
71046       delete arg1;
71047     } catch (std::out_of_range& e) {
71048       {
71049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71050       };
71051     } catch (std::exception& e) {
71052       {
71053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71054       };
71055     } catch (Dali::DaliException e) {
71056       {
71057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71058       };
71059     } catch (...) {
71060       {
71061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71062       };
71063     }
71064   }
71065
71066 }
71067
71068
71069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
71070   int jresult ;
71071   int result;
71072
71073   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
71074   jresult = (int)result;
71075   return jresult;
71076 }
71077
71078
71079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
71080   int jresult ;
71081   int result;
71082
71083   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
71084   jresult = (int)result;
71085   return jresult;
71086 }
71087
71088
71089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
71090   int jresult ;
71091   int result;
71092
71093   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
71094   jresult = (int)result;
71095   return jresult;
71096 }
71097
71098
71099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
71100   void * jresult ;
71101   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
71102
71103   {
71104     try {
71105       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
71106     } catch (std::out_of_range& e) {
71107       {
71108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71109       };
71110     } catch (std::exception& e) {
71111       {
71112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71113       };
71114     } catch (Dali::DaliException e) {
71115       {
71116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71117       };
71118     } catch (...) {
71119       {
71120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71121       };
71122     }
71123   }
71124
71125   jresult = (void *)result;
71126   return jresult;
71127 }
71128
71129
71130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
71131   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
71132
71133   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
71134   {
71135     try {
71136       delete arg1;
71137     } catch (std::out_of_range& e) {
71138       {
71139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71140       };
71141     } catch (std::exception& e) {
71142       {
71143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71144       };
71145     } catch (Dali::DaliException e) {
71146       {
71147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71148       };
71149     } catch (...) {
71150       {
71151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71152       };
71153     }
71154   }
71155
71156 }
71157
71158
71159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
71160   void * jresult ;
71161   Dali::Toolkit::FlexContainer *result = 0 ;
71162
71163   {
71164     try {
71165       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
71166     } catch (std::out_of_range& e) {
71167       {
71168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71169       };
71170     } catch (std::exception& e) {
71171       {
71172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71173       };
71174     } catch (Dali::DaliException e) {
71175       {
71176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71177       };
71178     } catch (...) {
71179       {
71180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71181       };
71182     }
71183   }
71184
71185   jresult = (void *)result;
71186   return jresult;
71187 }
71188
71189
71190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
71191   void * jresult ;
71192   Dali::Toolkit::FlexContainer *arg1 = 0 ;
71193   Dali::Toolkit::FlexContainer *result = 0 ;
71194
71195   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71196   if (!arg1) {
71197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71198     return 0;
71199   }
71200   {
71201     try {
71202       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
71203     } catch (std::out_of_range& e) {
71204       {
71205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71206       };
71207     } catch (std::exception& e) {
71208       {
71209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71210       };
71211     } catch (Dali::DaliException e) {
71212       {
71213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71214       };
71215     } catch (...) {
71216       {
71217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71218       };
71219     }
71220   }
71221
71222   jresult = (void *)result;
71223   return jresult;
71224 }
71225
71226
71227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
71228   void * jresult ;
71229   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71230   Dali::Toolkit::FlexContainer *arg2 = 0 ;
71231   Dali::Toolkit::FlexContainer *result = 0 ;
71232
71233   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71234   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
71235   if (!arg2) {
71236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
71237     return 0;
71238   }
71239   {
71240     try {
71241       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
71242     } catch (std::out_of_range& e) {
71243       {
71244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71245       };
71246     } catch (std::exception& e) {
71247       {
71248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71249       };
71250     } catch (Dali::DaliException e) {
71251       {
71252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71253       };
71254     } catch (...) {
71255       {
71256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71257       };
71258     }
71259   }
71260
71261   jresult = (void *)result;
71262   return jresult;
71263 }
71264
71265
71266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
71267   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
71268
71269   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
71270   {
71271     try {
71272       delete arg1;
71273     } catch (std::out_of_range& e) {
71274       {
71275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71276       };
71277     } catch (std::exception& e) {
71278       {
71279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71280       };
71281     } catch (Dali::DaliException e) {
71282       {
71283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71284       };
71285     } catch (...) {
71286       {
71287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71288       };
71289     }
71290   }
71291
71292 }
71293
71294
71295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
71296   void * jresult ;
71297   Dali::Toolkit::FlexContainer result;
71298
71299   {
71300     try {
71301       result = Dali::Toolkit::FlexContainer::New();
71302     } catch (std::out_of_range& e) {
71303       {
71304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71305       };
71306     } catch (std::exception& e) {
71307       {
71308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71309       };
71310     } catch (Dali::DaliException e) {
71311       {
71312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71313       };
71314     } catch (...) {
71315       {
71316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71317       };
71318     }
71319   }
71320
71321   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71322   return jresult;
71323 }
71324
71325
71326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
71327   void * jresult ;
71328   Dali::BaseHandle arg1 ;
71329   Dali::BaseHandle *argp1 ;
71330   Dali::Toolkit::FlexContainer result;
71331
71332   argp1 = (Dali::BaseHandle *)jarg1;
71333   if (!argp1) {
71334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71335     return 0;
71336   }
71337   arg1 = *argp1;
71338   {
71339     try {
71340       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
71341     } catch (std::out_of_range& e) {
71342       {
71343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71344       };
71345     } catch (std::exception& e) {
71346       {
71347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71348       };
71349     } catch (Dali::DaliException e) {
71350       {
71351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71352       };
71353     } catch (...) {
71354       {
71355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71356       };
71357     }
71358   }
71359
71360   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
71361   return jresult;
71362 }
71363
71364
71365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_RESOURCE_URL_get() {
71366   int jresult ;
71367   int result;
71368
71369   result = (int)Dali::Toolkit::ImageView::Property::RESOURCE_URL;
71370   jresult = (int)result;
71371   return jresult;
71372 }
71373
71374
71375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
71376   int jresult ;
71377   int result;
71378
71379   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
71380   jresult = (int)result;
71381   return jresult;
71382 }
71383
71384
71385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
71386   int jresult ;
71387   int result;
71388
71389   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
71390   jresult = (int)result;
71391   return jresult;
71392 }
71393
71394
71395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
71396   int jresult ;
71397   int result;
71398
71399   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
71400   jresult = (int)result;
71401   return jresult;
71402 }
71403
71404
71405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
71406   void * jresult ;
71407   Dali::Toolkit::ImageView::Property *result = 0 ;
71408
71409   {
71410     try {
71411       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
71412     } catch (std::out_of_range& e) {
71413       {
71414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71415       };
71416     } catch (std::exception& e) {
71417       {
71418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71419       };
71420     } catch (Dali::DaliException e) {
71421       {
71422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71423       };
71424     } catch (...) {
71425       {
71426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71427       };
71428     }
71429   }
71430
71431   jresult = (void *)result;
71432   return jresult;
71433 }
71434
71435
71436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
71437   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
71438
71439   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
71440   {
71441     try {
71442       delete arg1;
71443     } catch (std::out_of_range& e) {
71444       {
71445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71446       };
71447     } catch (std::exception& e) {
71448       {
71449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71450       };
71451     } catch (Dali::DaliException e) {
71452       {
71453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71454       };
71455     } catch (...) {
71456       {
71457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71458       };
71459     }
71460   }
71461
71462 }
71463
71464
71465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
71466   void * jresult ;
71467   Dali::Toolkit::ImageView *result = 0 ;
71468
71469   {
71470     try {
71471       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
71472     } catch (std::out_of_range& e) {
71473       {
71474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71475       };
71476     } catch (std::exception& e) {
71477       {
71478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71479       };
71480     } catch (Dali::DaliException e) {
71481       {
71482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71483       };
71484     } catch (...) {
71485       {
71486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71487       };
71488     }
71489   }
71490
71491   jresult = (void *)result;
71492   return jresult;
71493 }
71494
71495
71496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
71497   void * jresult ;
71498   Dali::Toolkit::ImageView result;
71499
71500   {
71501     try {
71502       result = Dali::Toolkit::ImageView::New();
71503     } catch (std::out_of_range& e) {
71504       {
71505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71506       };
71507     } catch (std::exception& e) {
71508       {
71509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71510       };
71511     } catch (Dali::DaliException e) {
71512       {
71513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71514       };
71515     } catch (...) {
71516       {
71517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71518       };
71519     }
71520   }
71521
71522   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71523   return jresult;
71524 }
71525
71526
71527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
71528   void * jresult ;
71529   Dali::Image arg1 ;
71530   Dali::Image *argp1 ;
71531   Dali::Toolkit::ImageView result;
71532
71533   argp1 = (Dali::Image *)jarg1;
71534   if (!argp1) {
71535     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71536     return 0;
71537   }
71538   arg1 = *argp1;
71539   {
71540     try {
71541       result = Dali::Toolkit::ImageView::New(arg1);
71542     } catch (std::out_of_range& e) {
71543       {
71544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71545       };
71546     } catch (std::exception& e) {
71547       {
71548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71549       };
71550     } catch (Dali::DaliException e) {
71551       {
71552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71553       };
71554     } catch (...) {
71555       {
71556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71557       };
71558     }
71559   }
71560
71561   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71562   return jresult;
71563 }
71564
71565
71566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
71567   void * jresult ;
71568   std::string *arg1 = 0 ;
71569   Dali::Toolkit::ImageView result;
71570
71571   if (!jarg1) {
71572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71573     return 0;
71574   }
71575   std::string arg1_str(jarg1);
71576   arg1 = &arg1_str;
71577   {
71578     try {
71579       result = Dali::Toolkit::ImageView::New((std::string const &)*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
71601   //argout typemap for const std::string&
71602
71603   return jresult;
71604 }
71605
71606
71607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
71608   void * jresult ;
71609   std::string *arg1 = 0 ;
71610   Dali::ImageDimensions arg2 ;
71611   Dali::ImageDimensions *argp2 ;
71612   Dali::Toolkit::ImageView result;
71613
71614   if (!jarg1) {
71615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71616     return 0;
71617   }
71618   std::string arg1_str(jarg1);
71619   arg1 = &arg1_str;
71620   argp2 = (Dali::ImageDimensions *)jarg2;
71621   if (!argp2) {
71622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71623     return 0;
71624   }
71625   arg2 = *argp2;
71626   {
71627     try {
71628       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
71629     } catch (std::out_of_range& e) {
71630       {
71631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71632       };
71633     } catch (std::exception& e) {
71634       {
71635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71636       };
71637     } catch (Dali::DaliException e) {
71638       {
71639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71640       };
71641     } catch (...) {
71642       {
71643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71644       };
71645     }
71646   }
71647
71648   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71649
71650   //argout typemap for const std::string&
71651
71652   return jresult;
71653 }
71654
71655
71656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
71657   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71658
71659   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71660   {
71661     try {
71662       delete arg1;
71663     } catch (std::out_of_range& e) {
71664       {
71665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71666       };
71667     } catch (std::exception& e) {
71668       {
71669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71670       };
71671     } catch (Dali::DaliException e) {
71672       {
71673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71674       };
71675     } catch (...) {
71676       {
71677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71678       };
71679     }
71680   }
71681
71682 }
71683
71684
71685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
71686   void * jresult ;
71687   Dali::Toolkit::ImageView *arg1 = 0 ;
71688   Dali::Toolkit::ImageView *result = 0 ;
71689
71690   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71691   if (!arg1) {
71692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71693     return 0;
71694   }
71695   {
71696     try {
71697       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
71698     } catch (std::out_of_range& e) {
71699       {
71700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71701       };
71702     } catch (std::exception& e) {
71703       {
71704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71705       };
71706     } catch (Dali::DaliException e) {
71707       {
71708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71709       };
71710     } catch (...) {
71711       {
71712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71713       };
71714     }
71715   }
71716
71717   jresult = (void *)result;
71718   return jresult;
71719 }
71720
71721
71722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
71723   void * jresult ;
71724   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71725   Dali::Toolkit::ImageView *arg2 = 0 ;
71726   Dali::Toolkit::ImageView *result = 0 ;
71727
71728   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71729   arg2 = (Dali::Toolkit::ImageView *)jarg2;
71730   if (!arg2) {
71731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
71732     return 0;
71733   }
71734   {
71735     try {
71736       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
71737     } catch (std::out_of_range& e) {
71738       {
71739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71740       };
71741     } catch (std::exception& e) {
71742       {
71743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71744       };
71745     } catch (Dali::DaliException e) {
71746       {
71747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71748       };
71749     } catch (...) {
71750       {
71751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71752       };
71753     }
71754   }
71755
71756   jresult = (void *)result;
71757   return jresult;
71758 }
71759
71760
71761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
71762   void * jresult ;
71763   Dali::BaseHandle arg1 ;
71764   Dali::BaseHandle *argp1 ;
71765   Dali::Toolkit::ImageView result;
71766
71767   argp1 = (Dali::BaseHandle *)jarg1;
71768   if (!argp1) {
71769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71770     return 0;
71771   }
71772   arg1 = *argp1;
71773   {
71774     try {
71775       result = Dali::Toolkit::ImageView::DownCast(arg1);
71776     } catch (std::out_of_range& e) {
71777       {
71778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71779       };
71780     } catch (std::exception& e) {
71781       {
71782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71783       };
71784     } catch (Dali::DaliException e) {
71785       {
71786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71787       };
71788     } catch (...) {
71789       {
71790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71791       };
71792     }
71793   }
71794
71795   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
71796   return jresult;
71797 }
71798
71799
71800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
71801   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71802   Dali::Image arg2 ;
71803   Dali::Image *argp2 ;
71804
71805   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71806   argp2 = (Dali::Image *)jarg2;
71807   if (!argp2) {
71808     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
71809     return ;
71810   }
71811   arg2 = *argp2;
71812   {
71813     try {
71814       (arg1)->SetImage(arg2);
71815     } catch (std::out_of_range& e) {
71816       {
71817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71818       };
71819     } catch (std::exception& e) {
71820       {
71821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71822       };
71823     } catch (Dali::DaliException e) {
71824       {
71825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71826       };
71827     } catch (...) {
71828       {
71829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71830       };
71831     }
71832   }
71833
71834 }
71835
71836
71837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
71838   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71839   std::string *arg2 = 0 ;
71840
71841   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71842   if (!jarg2) {
71843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71844     return ;
71845   }
71846   std::string arg2_str(jarg2);
71847   arg2 = &arg2_str;
71848   {
71849     try {
71850       (arg1)->SetImage((std::string const &)*arg2);
71851     } catch (std::out_of_range& e) {
71852       {
71853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71854       };
71855     } catch (std::exception& e) {
71856       {
71857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71858       };
71859     } catch (Dali::DaliException e) {
71860       {
71861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71862       };
71863     } catch (...) {
71864       {
71865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71866       };
71867     }
71868   }
71869
71870
71871   //argout typemap for const std::string&
71872
71873 }
71874
71875
71876 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
71877   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71878   std::string *arg2 = 0 ;
71879   Dali::ImageDimensions arg3 ;
71880   Dali::ImageDimensions *argp3 ;
71881
71882   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71883   if (!jarg2) {
71884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
71885     return ;
71886   }
71887   std::string arg2_str(jarg2);
71888   arg2 = &arg2_str;
71889   argp3 = (Dali::ImageDimensions *)jarg3;
71890   if (!argp3) {
71891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
71892     return ;
71893   }
71894   arg3 = *argp3;
71895   {
71896     try {
71897       (arg1)->SetImage((std::string const &)*arg2,arg3);
71898     } catch (std::out_of_range& e) {
71899       {
71900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71901       };
71902     } catch (std::exception& e) {
71903       {
71904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71905       };
71906     } catch (Dali::DaliException e) {
71907       {
71908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71909       };
71910     } catch (...) {
71911       {
71912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71913       };
71914     }
71915   }
71916
71917
71918   //argout typemap for const std::string&
71919
71920 }
71921
71922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
71923   void * jresult ;
71924   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
71925   Dali::Image result;
71926
71927   arg1 = (Dali::Toolkit::ImageView *)jarg1;
71928   {
71929     try {
71930       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
71931     } catch (std::out_of_range& e) {
71932       {
71933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71934       };
71935     } catch (std::exception& e) {
71936       {
71937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71938       };
71939     } catch (Dali::DaliException e) {
71940       {
71941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71942       };
71943     } catch (...) {
71944       {
71945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71946       };
71947     }
71948   }
71949
71950   jresult = new Dali::Image((const Dali::Image &)result);
71951   return jresult;
71952 }
71953
71954
71955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
71956   int jresult ;
71957   int result;
71958
71959   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
71960   jresult = (int)result;
71961   return jresult;
71962 }
71963
71964
71965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
71966   int jresult ;
71967   int result;
71968
71969   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
71970   jresult = (int)result;
71971   return jresult;
71972 }
71973
71974
71975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
71976   int jresult ;
71977   int result;
71978
71979   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
71980   jresult = (int)result;
71981   return jresult;
71982 }
71983
71984
71985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
71986   int jresult ;
71987   int result;
71988
71989   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
71990   jresult = (int)result;
71991   return jresult;
71992 }
71993
71994
71995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
71996   int jresult ;
71997   int result;
71998
71999   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
72000   jresult = (int)result;
72001   return jresult;
72002 }
72003
72004
72005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
72006   int jresult ;
72007   int result;
72008
72009   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
72010   jresult = (int)result;
72011   return jresult;
72012 }
72013
72014
72015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
72016   int jresult ;
72017   int result;
72018
72019   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
72020   jresult = (int)result;
72021   return jresult;
72022 }
72023
72024
72025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
72026   int jresult ;
72027   int result;
72028
72029   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
72030   jresult = (int)result;
72031   return jresult;
72032 }
72033
72034
72035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
72036   void * jresult ;
72037   Dali::Toolkit::Model3dView::Property *result = 0 ;
72038
72039   {
72040     try {
72041       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
72042     } catch (std::out_of_range& e) {
72043       {
72044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72045       };
72046     } catch (std::exception& e) {
72047       {
72048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72049       };
72050     } catch (Dali::DaliException e) {
72051       {
72052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72053       };
72054     } catch (...) {
72055       {
72056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72057       };
72058     }
72059   }
72060
72061   jresult = (void *)result;
72062   return jresult;
72063 }
72064
72065
72066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
72067   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
72068
72069   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
72070   {
72071     try {
72072       delete arg1;
72073     } catch (std::out_of_range& e) {
72074       {
72075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72076       };
72077     } catch (std::exception& e) {
72078       {
72079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72080       };
72081     } catch (Dali::DaliException e) {
72082       {
72083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72084       };
72085     } catch (...) {
72086       {
72087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72088       };
72089     }
72090   }
72091
72092 }
72093
72094
72095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
72096   void * jresult ;
72097   Dali::Toolkit::Model3dView result;
72098
72099   {
72100     try {
72101       result = Dali::Toolkit::Model3dView::New();
72102     } catch (std::out_of_range& e) {
72103       {
72104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72105       };
72106     } catch (std::exception& e) {
72107       {
72108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72109       };
72110     } catch (Dali::DaliException e) {
72111       {
72112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72113       };
72114     } catch (...) {
72115       {
72116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72117       };
72118     }
72119   }
72120
72121   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72122   return jresult;
72123 }
72124
72125
72126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
72127   void * jresult ;
72128   std::string *arg1 = 0 ;
72129   std::string *arg2 = 0 ;
72130   std::string *arg3 = 0 ;
72131   Dali::Toolkit::Model3dView result;
72132
72133   if (!jarg1) {
72134     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72135     return 0;
72136   }
72137   std::string arg1_str(jarg1);
72138   arg1 = &arg1_str;
72139   if (!jarg2) {
72140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72141     return 0;
72142   }
72143   std::string arg2_str(jarg2);
72144   arg2 = &arg2_str;
72145   if (!jarg3) {
72146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
72147     return 0;
72148   }
72149   std::string arg3_str(jarg3);
72150   arg3 = &arg3_str;
72151   {
72152     try {
72153       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
72154     } catch (std::out_of_range& e) {
72155       {
72156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72157       };
72158     } catch (std::exception& e) {
72159       {
72160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72161       };
72162     } catch (Dali::DaliException e) {
72163       {
72164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72165       };
72166     } catch (...) {
72167       {
72168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72169       };
72170     }
72171   }
72172
72173   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72174
72175   //argout typemap for const std::string&
72176
72177
72178   //argout typemap for const std::string&
72179
72180
72181   //argout typemap for const std::string&
72182
72183   return jresult;
72184 }
72185
72186
72187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
72188   void * jresult ;
72189   Dali::Toolkit::Model3dView *result = 0 ;
72190
72191   {
72192     try {
72193       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
72194     } catch (std::out_of_range& e) {
72195       {
72196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72197       };
72198     } catch (std::exception& e) {
72199       {
72200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72201       };
72202     } catch (Dali::DaliException e) {
72203       {
72204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72205       };
72206     } catch (...) {
72207       {
72208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72209       };
72210     }
72211   }
72212
72213   jresult = (void *)result;
72214   return jresult;
72215 }
72216
72217
72218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
72219   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72220
72221   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72222   {
72223     try {
72224       delete arg1;
72225     } catch (std::out_of_range& e) {
72226       {
72227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72228       };
72229     } catch (std::exception& e) {
72230       {
72231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72232       };
72233     } catch (Dali::DaliException e) {
72234       {
72235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72236       };
72237     } catch (...) {
72238       {
72239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72240       };
72241     }
72242   }
72243
72244 }
72245
72246
72247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
72248   void * jresult ;
72249   Dali::Toolkit::Model3dView *arg1 = 0 ;
72250   Dali::Toolkit::Model3dView *result = 0 ;
72251
72252   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72253   if (!arg1) {
72254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72255     return 0;
72256   }
72257   {
72258     try {
72259       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
72260     } catch (std::out_of_range& e) {
72261       {
72262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72263       };
72264     } catch (std::exception& e) {
72265       {
72266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72267       };
72268     } catch (Dali::DaliException e) {
72269       {
72270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72271       };
72272     } catch (...) {
72273       {
72274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72275       };
72276     }
72277   }
72278
72279   jresult = (void *)result;
72280   return jresult;
72281 }
72282
72283
72284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
72285   void * jresult ;
72286   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
72287   Dali::Toolkit::Model3dView *arg2 = 0 ;
72288   Dali::Toolkit::Model3dView *result = 0 ;
72289
72290   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
72291   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
72292   if (!arg2) {
72293     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
72294     return 0;
72295   }
72296   {
72297     try {
72298       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
72299     } catch (std::out_of_range& e) {
72300       {
72301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72302       };
72303     } catch (std::exception& e) {
72304       {
72305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72306       };
72307     } catch (Dali::DaliException e) {
72308       {
72309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72310       };
72311     } catch (...) {
72312       {
72313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72314       };
72315     }
72316   }
72317
72318   jresult = (void *)result;
72319   return jresult;
72320 }
72321
72322
72323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
72324   void * jresult ;
72325   Dali::BaseHandle arg1 ;
72326   Dali::BaseHandle *argp1 ;
72327   Dali::Toolkit::Model3dView result;
72328
72329   argp1 = (Dali::BaseHandle *)jarg1;
72330   if (!argp1) {
72331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72332     return 0;
72333   }
72334   arg1 = *argp1;
72335   {
72336     try {
72337       result = Dali::Toolkit::Model3dView::DownCast(arg1);
72338     } catch (std::out_of_range& e) {
72339       {
72340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72341       };
72342     } catch (std::exception& e) {
72343       {
72344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72345       };
72346     } catch (Dali::DaliException e) {
72347       {
72348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72349       };
72350     } catch (...) {
72351       {
72352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72353       };
72354     }
72355   }
72356
72357   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
72358   return jresult;
72359 }
72360
72361
72362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
72363   int jresult ;
72364   int result;
72365
72366   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
72367   jresult = (int)result;
72368   return jresult;
72369 }
72370
72371
72372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
72373   int jresult ;
72374   int result;
72375
72376   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
72377   jresult = (int)result;
72378   return jresult;
72379 }
72380
72381
72382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
72383   int jresult ;
72384   int result;
72385
72386   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
72387   jresult = (int)result;
72388   return jresult;
72389 }
72390
72391
72392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
72393   int jresult ;
72394   int result;
72395
72396   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
72397   jresult = (int)result;
72398   return jresult;
72399 }
72400
72401
72402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
72403   int jresult ;
72404   int result;
72405
72406   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
72407   jresult = (int)result;
72408   return jresult;
72409 }
72410
72411
72412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
72413   int jresult ;
72414   int result;
72415
72416   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
72417   jresult = (int)result;
72418   return jresult;
72419 }
72420
72421
72422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
72423   int jresult ;
72424   int result;
72425
72426   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
72427   jresult = (int)result;
72428   return jresult;
72429 }
72430
72431
72432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
72433   int jresult ;
72434   int result;
72435
72436   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
72437   jresult = (int)result;
72438   return jresult;
72439 }
72440
72441
72442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
72443   int jresult ;
72444   int result;
72445
72446   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
72447   jresult = (int)result;
72448   return jresult;
72449 }
72450
72451
72452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
72453   void * jresult ;
72454   Dali::Toolkit::ScrollBar::Property *result = 0 ;
72455
72456   {
72457     try {
72458       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
72459     } catch (std::out_of_range& e) {
72460       {
72461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72462       };
72463     } catch (std::exception& e) {
72464       {
72465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72466       };
72467     } catch (Dali::DaliException e) {
72468       {
72469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72470       };
72471     } catch (...) {
72472       {
72473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72474       };
72475     }
72476   }
72477
72478   jresult = (void *)result;
72479   return jresult;
72480 }
72481
72482
72483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
72484   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
72485
72486   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
72487   {
72488     try {
72489       delete arg1;
72490     } catch (std::out_of_range& e) {
72491       {
72492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72493       };
72494     } catch (std::exception& e) {
72495       {
72496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72497       };
72498     } catch (Dali::DaliException e) {
72499       {
72500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72501       };
72502     } catch (...) {
72503       {
72504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72505       };
72506     }
72507   }
72508
72509 }
72510
72511
72512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
72513   void * jresult ;
72514   Dali::Toolkit::ScrollBar *result = 0 ;
72515
72516   {
72517     try {
72518       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
72519     } catch (std::out_of_range& e) {
72520       {
72521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72522       };
72523     } catch (std::exception& e) {
72524       {
72525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72526       };
72527     } catch (Dali::DaliException e) {
72528       {
72529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72530       };
72531     } catch (...) {
72532       {
72533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72534       };
72535     }
72536   }
72537
72538   jresult = (void *)result;
72539   return jresult;
72540 }
72541
72542
72543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
72544   void * jresult ;
72545   Dali::Toolkit::ScrollBar *arg1 = 0 ;
72546   Dali::Toolkit::ScrollBar *result = 0 ;
72547
72548   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72549   if (!arg1) {
72550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72551     return 0;
72552   }
72553   {
72554     try {
72555       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
72556     } catch (std::out_of_range& e) {
72557       {
72558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72559       };
72560     } catch (std::exception& e) {
72561       {
72562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72563       };
72564     } catch (Dali::DaliException e) {
72565       {
72566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72567       };
72568     } catch (...) {
72569       {
72570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72571       };
72572     }
72573   }
72574
72575   jresult = (void *)result;
72576   return jresult;
72577 }
72578
72579
72580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
72581   void * jresult ;
72582   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72583   Dali::Toolkit::ScrollBar *arg2 = 0 ;
72584   Dali::Toolkit::ScrollBar *result = 0 ;
72585
72586   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72587   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
72588   if (!arg2) {
72589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
72590     return 0;
72591   }
72592   {
72593     try {
72594       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
72595     } catch (std::out_of_range& e) {
72596       {
72597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72598       };
72599     } catch (std::exception& e) {
72600       {
72601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72602       };
72603     } catch (Dali::DaliException e) {
72604       {
72605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72606       };
72607     } catch (...) {
72608       {
72609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72610       };
72611     }
72612   }
72613
72614   jresult = (void *)result;
72615   return jresult;
72616 }
72617
72618
72619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
72620   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72621
72622   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72623   {
72624     try {
72625       delete arg1;
72626     } catch (std::out_of_range& e) {
72627       {
72628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72629       };
72630     } catch (std::exception& e) {
72631       {
72632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72633       };
72634     } catch (Dali::DaliException e) {
72635       {
72636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72637       };
72638     } catch (...) {
72639       {
72640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72641       };
72642     }
72643   }
72644
72645 }
72646
72647
72648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
72649   void * jresult ;
72650   Dali::Toolkit::ScrollBar::Direction arg1 ;
72651   Dali::Toolkit::ScrollBar result;
72652
72653   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
72654   {
72655     try {
72656       result = Dali::Toolkit::ScrollBar::New(arg1);
72657     } catch (std::out_of_range& e) {
72658       {
72659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72660       };
72661     } catch (std::exception& e) {
72662       {
72663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72664       };
72665     } catch (Dali::DaliException e) {
72666       {
72667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72668       };
72669     } catch (...) {
72670       {
72671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72672       };
72673     }
72674   }
72675
72676   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72677   return jresult;
72678 }
72679
72680
72681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
72682   void * jresult ;
72683   Dali::Toolkit::ScrollBar result;
72684
72685   {
72686     try {
72687       result = Dali::Toolkit::ScrollBar::New();
72688     } catch (std::out_of_range& e) {
72689       {
72690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72691       };
72692     } catch (std::exception& e) {
72693       {
72694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72695       };
72696     } catch (Dali::DaliException e) {
72697       {
72698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72699       };
72700     } catch (...) {
72701       {
72702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72703       };
72704     }
72705   }
72706
72707   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72708   return jresult;
72709 }
72710
72711
72712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
72713   void * jresult ;
72714   Dali::BaseHandle arg1 ;
72715   Dali::BaseHandle *argp1 ;
72716   Dali::Toolkit::ScrollBar result;
72717
72718   argp1 = (Dali::BaseHandle *)jarg1;
72719   if (!argp1) {
72720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72721     return 0;
72722   }
72723   arg1 = *argp1;
72724   {
72725     try {
72726       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
72727     } catch (std::out_of_range& e) {
72728       {
72729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72730       };
72731     } catch (std::exception& e) {
72732       {
72733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72734       };
72735     } catch (Dali::DaliException e) {
72736       {
72737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72738       };
72739     } catch (...) {
72740       {
72741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72742       };
72743     }
72744   }
72745
72746   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
72747   return jresult;
72748 }
72749
72750
72751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
72752   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72753   Dali::Handle arg2 ;
72754   Dali::Property::Index arg3 ;
72755   Dali::Property::Index arg4 ;
72756   Dali::Property::Index arg5 ;
72757   Dali::Property::Index arg6 ;
72758   Dali::Handle *argp2 ;
72759
72760   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72761   argp2 = (Dali::Handle *)jarg2;
72762   if (!argp2) {
72763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
72764     return ;
72765   }
72766   arg2 = *argp2;
72767   arg3 = (Dali::Property::Index)jarg3;
72768   arg4 = (Dali::Property::Index)jarg4;
72769   arg5 = (Dali::Property::Index)jarg5;
72770   arg6 = (Dali::Property::Index)jarg6;
72771   {
72772     try {
72773       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
72774     } catch (std::out_of_range& e) {
72775       {
72776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72777       };
72778     } catch (std::exception& e) {
72779       {
72780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72781       };
72782     } catch (Dali::DaliException e) {
72783       {
72784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72785       };
72786     } catch (...) {
72787       {
72788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72789       };
72790     }
72791   }
72792
72793 }
72794
72795
72796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
72797   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72798   Dali::Actor arg2 ;
72799   Dali::Actor *argp2 ;
72800
72801   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72802   argp2 = (Dali::Actor *)jarg2;
72803   if (!argp2) {
72804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72805     return ;
72806   }
72807   arg2 = *argp2;
72808   {
72809     try {
72810       (arg1)->SetScrollIndicator(arg2);
72811     } catch (std::out_of_range& e) {
72812       {
72813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72814       };
72815     } catch (std::exception& e) {
72816       {
72817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72818       };
72819     } catch (Dali::DaliException e) {
72820       {
72821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72822       };
72823     } catch (...) {
72824       {
72825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72826       };
72827     }
72828   }
72829
72830 }
72831
72832
72833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
72834   void * jresult ;
72835   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72836   Dali::Actor result;
72837
72838   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72839   {
72840     try {
72841       result = (arg1)->GetScrollIndicator();
72842     } catch (std::out_of_range& e) {
72843       {
72844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72845       };
72846     } catch (std::exception& e) {
72847       {
72848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72849       };
72850     } catch (Dali::DaliException e) {
72851       {
72852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72853       };
72854     } catch (...) {
72855       {
72856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72857       };
72858     }
72859   }
72860
72861   jresult = new Dali::Actor((const Dali::Actor &)result);
72862   return jresult;
72863 }
72864
72865
72866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
72867   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72868   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
72869
72870   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72871   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
72872   if (!arg2) {
72873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
72874     return ;
72875   }
72876   {
72877     try {
72878       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
72879     } catch (std::out_of_range& e) {
72880       {
72881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72882       };
72883     } catch (std::exception& e) {
72884       {
72885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72886       };
72887     } catch (Dali::DaliException e) {
72888       {
72889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72890       };
72891     } catch (...) {
72892       {
72893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72894       };
72895     }
72896   }
72897
72898 }
72899
72900
72901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
72902   void * jresult ;
72903   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72904
72905   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72906   {
72907     try {
72908       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()));
72909     } catch (std::out_of_range& e) {
72910       {
72911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72912       };
72913     } catch (std::exception& e) {
72914       {
72915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72916       };
72917     } catch (...) {
72918       {
72919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72920       };
72921     }
72922   }
72923   return jresult;
72924 }
72925
72926
72927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
72928   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72929   Dali::Toolkit::ScrollBar::Direction arg2 ;
72930
72931   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72932   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
72933   {
72934     try {
72935       (arg1)->SetScrollDirection(arg2);
72936     } catch (std::out_of_range& e) {
72937       {
72938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72939       };
72940     } catch (std::exception& e) {
72941       {
72942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72943       };
72944     } catch (Dali::DaliException e) {
72945       {
72946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72947       };
72948     } catch (...) {
72949       {
72950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72951       };
72952     }
72953   }
72954
72955 }
72956
72957
72958 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
72959   int jresult ;
72960   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72961   Dali::Toolkit::ScrollBar::Direction result;
72962
72963   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72964   {
72965     try {
72966       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
72967     } catch (std::out_of_range& e) {
72968       {
72969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72970       };
72971     } catch (std::exception& e) {
72972       {
72973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72974       };
72975     } catch (Dali::DaliException e) {
72976       {
72977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72978       };
72979     } catch (...) {
72980       {
72981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72982       };
72983     }
72984   }
72985
72986   jresult = (int)result;
72987   return jresult;
72988 }
72989
72990
72991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
72992   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
72993   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
72994
72995   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
72996   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
72997   {
72998     try {
72999       (arg1)->SetIndicatorHeightPolicy(arg2);
73000     } catch (std::out_of_range& e) {
73001       {
73002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73003       };
73004     } catch (std::exception& e) {
73005       {
73006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73007       };
73008     } catch (Dali::DaliException e) {
73009       {
73010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73011       };
73012     } catch (...) {
73013       {
73014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73015       };
73016     }
73017   }
73018
73019 }
73020
73021
73022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
73023   int jresult ;
73024   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73025   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
73026
73027   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73028   {
73029     try {
73030       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
73031     } catch (std::out_of_range& e) {
73032       {
73033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73034       };
73035     } catch (std::exception& e) {
73036       {
73037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73038       };
73039     } catch (Dali::DaliException e) {
73040       {
73041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73042       };
73043     } catch (...) {
73044       {
73045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73046       };
73047     }
73048   }
73049
73050   jresult = (int)result;
73051   return jresult;
73052 }
73053
73054
73055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
73056   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73057   float arg2 ;
73058
73059   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73060   arg2 = (float)jarg2;
73061   {
73062     try {
73063       (arg1)->SetIndicatorFixedHeight(arg2);
73064     } catch (std::out_of_range& e) {
73065       {
73066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73067       };
73068     } catch (std::exception& e) {
73069       {
73070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73071       };
73072     } catch (Dali::DaliException e) {
73073       {
73074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73075       };
73076     } catch (...) {
73077       {
73078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73079       };
73080     }
73081   }
73082
73083 }
73084
73085
73086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
73087   float jresult ;
73088   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73089   float result;
73090
73091   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73092   {
73093     try {
73094       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
73095     } catch (std::out_of_range& e) {
73096       {
73097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73098       };
73099     } catch (std::exception& e) {
73100       {
73101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73102       };
73103     } catch (Dali::DaliException e) {
73104       {
73105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73106       };
73107     } catch (...) {
73108       {
73109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73110       };
73111     }
73112   }
73113
73114   jresult = result;
73115   return jresult;
73116 }
73117
73118
73119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
73120   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73121   float arg2 ;
73122
73123   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73124   arg2 = (float)jarg2;
73125   {
73126     try {
73127       (arg1)->SetIndicatorShowDuration(arg2);
73128     } catch (std::out_of_range& e) {
73129       {
73130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73131       };
73132     } catch (std::exception& e) {
73133       {
73134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73135       };
73136     } catch (Dali::DaliException e) {
73137       {
73138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73139       };
73140     } catch (...) {
73141       {
73142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73143       };
73144     }
73145   }
73146
73147 }
73148
73149
73150 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
73151   float jresult ;
73152   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73153   float result;
73154
73155   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73156   {
73157     try {
73158       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
73159     } catch (std::out_of_range& e) {
73160       {
73161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73162       };
73163     } catch (std::exception& e) {
73164       {
73165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73166       };
73167     } catch (Dali::DaliException e) {
73168       {
73169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73170       };
73171     } catch (...) {
73172       {
73173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73174       };
73175     }
73176   }
73177
73178   jresult = result;
73179   return jresult;
73180 }
73181
73182
73183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
73184   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73185   float arg2 ;
73186
73187   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73188   arg2 = (float)jarg2;
73189   {
73190     try {
73191       (arg1)->SetIndicatorHideDuration(arg2);
73192     } catch (std::out_of_range& e) {
73193       {
73194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73195       };
73196     } catch (std::exception& e) {
73197       {
73198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73199       };
73200     } catch (Dali::DaliException e) {
73201       {
73202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73203       };
73204     } catch (...) {
73205       {
73206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73207       };
73208     }
73209   }
73210
73211 }
73212
73213
73214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
73215   float jresult ;
73216   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73217   float result;
73218
73219   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73220   {
73221     try {
73222       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
73223     } catch (std::out_of_range& e) {
73224       {
73225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73226       };
73227     } catch (std::exception& e) {
73228       {
73229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73230       };
73231     } catch (Dali::DaliException e) {
73232       {
73233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73234       };
73235     } catch (...) {
73236       {
73237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73238       };
73239     }
73240   }
73241
73242   jresult = result;
73243   return jresult;
73244 }
73245
73246
73247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
73248   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73249
73250   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73251   {
73252     try {
73253       (arg1)->ShowIndicator();
73254     } catch (std::out_of_range& e) {
73255       {
73256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73257       };
73258     } catch (std::exception& e) {
73259       {
73260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73261       };
73262     } catch (Dali::DaliException e) {
73263       {
73264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73265       };
73266     } catch (...) {
73267       {
73268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73269       };
73270     }
73271   }
73272
73273 }
73274
73275
73276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
73277   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73278
73279   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73280   {
73281     try {
73282       (arg1)->HideIndicator();
73283     } catch (std::out_of_range& e) {
73284       {
73285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73286       };
73287     } catch (std::exception& e) {
73288       {
73289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73290       };
73291     } catch (Dali::DaliException e) {
73292       {
73293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73294       };
73295     } catch (...) {
73296       {
73297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73298       };
73299     }
73300   }
73301
73302 }
73303
73304
73305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
73306   void * jresult ;
73307   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73308   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
73309
73310   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73311   {
73312     try {
73313       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
73314     } catch (std::out_of_range& e) {
73315       {
73316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73317       };
73318     } catch (std::exception& e) {
73319       {
73320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73321       };
73322     } catch (Dali::DaliException e) {
73323       {
73324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73325       };
73326     } catch (...) {
73327       {
73328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73329       };
73330     }
73331   }
73332
73333   jresult = (void *)result;
73334   return jresult;
73335 }
73336
73337
73338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
73339   void * jresult ;
73340   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
73341   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
73342
73343   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
73344   {
73345     try {
73346       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
73347     } catch (std::out_of_range& e) {
73348       {
73349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73350       };
73351     } catch (std::exception& e) {
73352       {
73353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73354       };
73355     } catch (Dali::DaliException e) {
73356       {
73357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73358       };
73359     } catch (...) {
73360       {
73361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73362       };
73363     }
73364   }
73365
73366   jresult = (void *)result;
73367   return jresult;
73368 }
73369
73370
73371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
73372   int jresult ;
73373   int result;
73374
73375   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
73376   jresult = (int)result;
73377   return jresult;
73378 }
73379
73380
73381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
73382   int jresult ;
73383   int result;
73384
73385   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
73386   jresult = (int)result;
73387   return jresult;
73388 }
73389
73390
73391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
73392   int jresult ;
73393   int result;
73394
73395   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
73396   jresult = (int)result;
73397   return jresult;
73398 }
73399
73400
73401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
73402   int jresult ;
73403   int result;
73404
73405   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
73406   jresult = (int)result;
73407   return jresult;
73408 }
73409
73410
73411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
73412   int jresult ;
73413   int result;
73414
73415   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
73416   jresult = (int)result;
73417   return jresult;
73418 }
73419
73420
73421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
73422   int jresult ;
73423   int result;
73424
73425   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
73426   jresult = (int)result;
73427   return jresult;
73428 }
73429
73430
73431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
73432   int jresult ;
73433   int result;
73434
73435   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
73436   jresult = (int)result;
73437   return jresult;
73438 }
73439
73440
73441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
73442   int jresult ;
73443   int result;
73444
73445   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
73446   jresult = (int)result;
73447   return jresult;
73448 }
73449
73450
73451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
73452   int jresult ;
73453   int result;
73454
73455   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
73456   jresult = (int)result;
73457   return jresult;
73458 }
73459
73460
73461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
73462   int jresult ;
73463   int result;
73464
73465   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
73466   jresult = (int)result;
73467   return jresult;
73468 }
73469
73470
73471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
73472   int jresult ;
73473   int result;
73474
73475   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
73476   jresult = (int)result;
73477   return jresult;
73478 }
73479
73480
73481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
73482   int jresult ;
73483   int result;
73484
73485   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
73486   jresult = (int)result;
73487   return jresult;
73488 }
73489
73490
73491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
73492   int jresult ;
73493   int result;
73494
73495   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
73496   jresult = (int)result;
73497   return jresult;
73498 }
73499
73500
73501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
73502   int jresult ;
73503   int result;
73504
73505   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
73506   jresult = (int)result;
73507   return jresult;
73508 }
73509
73510
73511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
73512   void * jresult ;
73513   Dali::Toolkit::Scrollable::Property *result = 0 ;
73514
73515   {
73516     try {
73517       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
73518     } catch (std::out_of_range& e) {
73519       {
73520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73521       };
73522     } catch (std::exception& e) {
73523       {
73524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73525       };
73526     } catch (Dali::DaliException e) {
73527       {
73528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73529       };
73530     } catch (...) {
73531       {
73532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73533       };
73534     }
73535   }
73536
73537   jresult = (void *)result;
73538   return jresult;
73539 }
73540
73541
73542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
73543   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
73544
73545   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
73546   {
73547     try {
73548       delete arg1;
73549     } catch (std::out_of_range& e) {
73550       {
73551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73552       };
73553     } catch (std::exception& e) {
73554       {
73555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73556       };
73557     } catch (Dali::DaliException e) {
73558       {
73559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73560       };
73561     } catch (...) {
73562       {
73563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73564       };
73565     }
73566   }
73567
73568 }
73569
73570
73571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
73572   void * jresult ;
73573   Dali::Toolkit::Scrollable *result = 0 ;
73574
73575   {
73576     try {
73577       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
73578     } catch (std::out_of_range& e) {
73579       {
73580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73581       };
73582     } catch (std::exception& e) {
73583       {
73584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73585       };
73586     } catch (Dali::DaliException e) {
73587       {
73588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73589       };
73590     } catch (...) {
73591       {
73592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73593       };
73594     }
73595   }
73596
73597   jresult = (void *)result;
73598   return jresult;
73599 }
73600
73601
73602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
73603   void * jresult ;
73604   Dali::Toolkit::Scrollable *arg1 = 0 ;
73605   Dali::Toolkit::Scrollable *result = 0 ;
73606
73607   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73608   if (!arg1) {
73609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73610     return 0;
73611   }
73612   {
73613     try {
73614       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
73615     } catch (std::out_of_range& e) {
73616       {
73617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73618       };
73619     } catch (std::exception& e) {
73620       {
73621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73622       };
73623     } catch (Dali::DaliException e) {
73624       {
73625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73626       };
73627     } catch (...) {
73628       {
73629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73630       };
73631     }
73632   }
73633
73634   jresult = (void *)result;
73635   return jresult;
73636 }
73637
73638
73639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
73640   void * jresult ;
73641   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73642   Dali::Toolkit::Scrollable *arg2 = 0 ;
73643   Dali::Toolkit::Scrollable *result = 0 ;
73644
73645   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73646   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
73647   if (!arg2) {
73648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
73649     return 0;
73650   }
73651   {
73652     try {
73653       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
73654     } catch (std::out_of_range& e) {
73655       {
73656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73657       };
73658     } catch (std::exception& e) {
73659       {
73660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73661       };
73662     } catch (Dali::DaliException e) {
73663       {
73664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73665       };
73666     } catch (...) {
73667       {
73668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73669       };
73670     }
73671   }
73672
73673   jresult = (void *)result;
73674   return jresult;
73675 }
73676
73677
73678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
73679   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73680
73681   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73682   {
73683     try {
73684       delete arg1;
73685     } catch (std::out_of_range& e) {
73686       {
73687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73688       };
73689     } catch (std::exception& e) {
73690       {
73691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73692       };
73693     } catch (Dali::DaliException e) {
73694       {
73695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73696       };
73697     } catch (...) {
73698       {
73699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73700       };
73701     }
73702   }
73703
73704 }
73705
73706
73707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
73708   void * jresult ;
73709   Dali::BaseHandle arg1 ;
73710   Dali::BaseHandle *argp1 ;
73711   Dali::Toolkit::Scrollable result;
73712
73713   argp1 = (Dali::BaseHandle *)jarg1;
73714   if (!argp1) {
73715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73716     return 0;
73717   }
73718   arg1 = *argp1;
73719   {
73720     try {
73721       result = Dali::Toolkit::Scrollable::DownCast(arg1);
73722     } catch (std::out_of_range& e) {
73723       {
73724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73725       };
73726     } catch (std::exception& e) {
73727       {
73728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73729       };
73730     } catch (Dali::DaliException e) {
73731       {
73732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73733       };
73734     } catch (...) {
73735       {
73736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73737       };
73738     }
73739   }
73740
73741   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
73742   return jresult;
73743 }
73744
73745
73746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
73747   unsigned int jresult ;
73748   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73749   bool result;
73750
73751   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73752   {
73753     try {
73754       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
73755     } catch (std::out_of_range& e) {
73756       {
73757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73758       };
73759     } catch (std::exception& e) {
73760       {
73761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73762       };
73763     } catch (Dali::DaliException e) {
73764       {
73765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73766       };
73767     } catch (...) {
73768       {
73769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73770       };
73771     }
73772   }
73773
73774   jresult = result;
73775   return jresult;
73776 }
73777
73778
73779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
73780   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73781   bool arg2 ;
73782
73783   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73784   arg2 = jarg2 ? true : false;
73785   {
73786     try {
73787       (arg1)->SetOvershootEnabled(arg2);
73788     } catch (std::out_of_range& e) {
73789       {
73790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73791       };
73792     } catch (std::exception& e) {
73793       {
73794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73795       };
73796     } catch (Dali::DaliException e) {
73797       {
73798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73799       };
73800     } catch (...) {
73801       {
73802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73803       };
73804     }
73805   }
73806
73807 }
73808
73809
73810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
73811   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73812   Dali::Vector4 *arg2 = 0 ;
73813
73814   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73815   arg2 = (Dali::Vector4 *)jarg2;
73816   if (!arg2) {
73817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
73818     return ;
73819   }
73820   {
73821     try {
73822       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
73823     } catch (std::out_of_range& e) {
73824       {
73825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73826       };
73827     } catch (std::exception& e) {
73828       {
73829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73830       };
73831     } catch (Dali::DaliException e) {
73832       {
73833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73834       };
73835     } catch (...) {
73836       {
73837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73838       };
73839     }
73840   }
73841
73842 }
73843
73844
73845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
73846   void * jresult ;
73847   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73848   Dali::Vector4 result;
73849
73850   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73851   {
73852     try {
73853       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
73854     } catch (std::out_of_range& e) {
73855       {
73856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73857       };
73858     } catch (std::exception& e) {
73859       {
73860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73861       };
73862     } catch (Dali::DaliException e) {
73863       {
73864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73865       };
73866     } catch (...) {
73867       {
73868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73869       };
73870     }
73871   }
73872
73873   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
73874   return jresult;
73875 }
73876
73877
73878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
73879   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73880   float arg2 ;
73881
73882   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73883   arg2 = (float)jarg2;
73884   {
73885     try {
73886       (arg1)->SetOvershootAnimationSpeed(arg2);
73887     } catch (std::out_of_range& e) {
73888       {
73889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73890       };
73891     } catch (std::exception& e) {
73892       {
73893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73894       };
73895     } catch (Dali::DaliException e) {
73896       {
73897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73898       };
73899     } catch (...) {
73900       {
73901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73902       };
73903     }
73904   }
73905
73906 }
73907
73908
73909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
73910   float jresult ;
73911   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73912   float result;
73913
73914   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73915   {
73916     try {
73917       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
73918     } catch (std::out_of_range& e) {
73919       {
73920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73921       };
73922     } catch (std::exception& e) {
73923       {
73924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73925       };
73926     } catch (Dali::DaliException e) {
73927       {
73928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73929       };
73930     } catch (...) {
73931       {
73932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73933       };
73934     }
73935   }
73936
73937   jresult = result;
73938   return jresult;
73939 }
73940
73941
73942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
73943   void * jresult ;
73944   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73945   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
73946
73947   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73948   {
73949     try {
73950       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
73951     } catch (std::out_of_range& e) {
73952       {
73953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73954       };
73955     } catch (std::exception& e) {
73956       {
73957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73958       };
73959     } catch (Dali::DaliException e) {
73960       {
73961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73962       };
73963     } catch (...) {
73964       {
73965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73966       };
73967     }
73968   }
73969
73970   jresult = (void *)result;
73971   return jresult;
73972 }
73973
73974
73975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
73976   void * jresult ;
73977   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
73978   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
73979
73980   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
73981   {
73982     try {
73983       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
73984     } catch (std::out_of_range& e) {
73985       {
73986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73987       };
73988     } catch (std::exception& e) {
73989       {
73990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73991       };
73992     } catch (Dali::DaliException e) {
73993       {
73994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73995       };
73996     } catch (...) {
73997       {
73998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73999       };
74000     }
74001   }
74002
74003   jresult = (void *)result;
74004   return jresult;
74005 }
74006
74007
74008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
74009   void * jresult ;
74010   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
74011   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
74012
74013   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
74014   {
74015     try {
74016       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
74017     } catch (std::out_of_range& e) {
74018       {
74019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74020       };
74021     } catch (std::exception& e) {
74022       {
74023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74024       };
74025     } catch (Dali::DaliException e) {
74026       {
74027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74028       };
74029     } catch (...) {
74030       {
74031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74032       };
74033     }
74034   }
74035
74036   jresult = (void *)result;
74037   return jresult;
74038 }
74039
74040
74041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
74042   unsigned int jresult ;
74043   Dali::Toolkit::ControlOrientation::Type arg1 ;
74044   bool result;
74045
74046   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74047   {
74048     try {
74049       result = (bool)Dali::Toolkit::IsVertical(arg1);
74050     } catch (std::out_of_range& e) {
74051       {
74052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74053       };
74054     } catch (std::exception& e) {
74055       {
74056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74057       };
74058     } catch (Dali::DaliException e) {
74059       {
74060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74061       };
74062     } catch (...) {
74063       {
74064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74065       };
74066     }
74067   }
74068
74069   jresult = result;
74070   return jresult;
74071 }
74072
74073
74074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
74075   unsigned int jresult ;
74076   Dali::Toolkit::ControlOrientation::Type arg1 ;
74077   bool result;
74078
74079   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
74080   {
74081     try {
74082       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
74083     } catch (std::out_of_range& e) {
74084       {
74085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74086       };
74087     } catch (std::exception& e) {
74088       {
74089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74090       };
74091     } catch (Dali::DaliException e) {
74092       {
74093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74094       };
74095     } catch (...) {
74096       {
74097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74098       };
74099     }
74100   }
74101
74102   jresult = result;
74103   return jresult;
74104 }
74105
74106
74107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
74108   void * jresult ;
74109   unsigned int arg1 ;
74110   unsigned int arg2 ;
74111   Dali::Toolkit::ItemRange *result = 0 ;
74112
74113   arg1 = (unsigned int)jarg1;
74114   arg2 = (unsigned int)jarg2;
74115   {
74116     try {
74117       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
74118     } catch (std::out_of_range& e) {
74119       {
74120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74121       };
74122     } catch (std::exception& e) {
74123       {
74124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74125       };
74126     } catch (Dali::DaliException e) {
74127       {
74128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74129       };
74130     } catch (...) {
74131       {
74132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74133       };
74134     }
74135   }
74136
74137   jresult = (void *)result;
74138   return jresult;
74139 }
74140
74141
74142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
74143   void * jresult ;
74144   Dali::Toolkit::ItemRange *arg1 = 0 ;
74145   Dali::Toolkit::ItemRange *result = 0 ;
74146
74147   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74148   if (!arg1) {
74149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74150     return 0;
74151   }
74152   {
74153     try {
74154       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
74155     } catch (std::out_of_range& e) {
74156       {
74157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74158       };
74159     } catch (std::exception& e) {
74160       {
74161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74162       };
74163     } catch (Dali::DaliException e) {
74164       {
74165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74166       };
74167     } catch (...) {
74168       {
74169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74170       };
74171     }
74172   }
74173
74174   jresult = (void *)result;
74175   return jresult;
74176 }
74177
74178
74179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
74180   void * jresult ;
74181   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74182   Dali::Toolkit::ItemRange *arg2 = 0 ;
74183   Dali::Toolkit::ItemRange *result = 0 ;
74184
74185   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74186   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74187   if (!arg2) {
74188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74189     return 0;
74190   }
74191   {
74192     try {
74193       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
74194     } catch (std::out_of_range& e) {
74195       {
74196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74197       };
74198     } catch (std::exception& e) {
74199       {
74200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74201       };
74202     } catch (Dali::DaliException e) {
74203       {
74204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74205       };
74206     } catch (...) {
74207       {
74208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74209       };
74210     }
74211   }
74212
74213   jresult = (void *)result;
74214   return jresult;
74215 }
74216
74217
74218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
74219   unsigned int jresult ;
74220   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74221   unsigned int arg2 ;
74222   bool result;
74223
74224   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74225   arg2 = (unsigned int)jarg2;
74226   {
74227     try {
74228       result = (bool)(arg1)->Within(arg2);
74229     } catch (std::out_of_range& e) {
74230       {
74231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74232       };
74233     } catch (std::exception& e) {
74234       {
74235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74236       };
74237     } catch (Dali::DaliException e) {
74238       {
74239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74240       };
74241     } catch (...) {
74242       {
74243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74244       };
74245     }
74246   }
74247
74248   jresult = result;
74249   return jresult;
74250 }
74251
74252
74253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
74254   void * jresult ;
74255   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74256   Dali::Toolkit::ItemRange *arg2 = 0 ;
74257   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74258
74259   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74260   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74261   if (!arg2) {
74262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
74263     return 0;
74264   }
74265   {
74266     try {
74267       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
74268     } catch (std::out_of_range& e) {
74269       {
74270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74271       };
74272     } catch (std::exception& e) {
74273       {
74274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74275       };
74276     } catch (Dali::DaliException e) {
74277       {
74278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74279       };
74280     } catch (...) {
74281       {
74282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74283       };
74284     }
74285   }
74286
74287   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74288   return jresult;
74289 }
74290
74291
74292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
74293   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74294   unsigned int arg2 ;
74295
74296   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74297   arg2 = (unsigned int)jarg2;
74298   if (arg1) (arg1)->begin = arg2;
74299 }
74300
74301
74302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
74303   unsigned int jresult ;
74304   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74305   unsigned int result;
74306
74307   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74308   result = (unsigned int) ((arg1)->begin);
74309   jresult = result;
74310   return jresult;
74311 }
74312
74313
74314 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
74315   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74316   unsigned int arg2 ;
74317
74318   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74319   arg2 = (unsigned int)jarg2;
74320   if (arg1) (arg1)->end = arg2;
74321 }
74322
74323
74324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
74325   unsigned int jresult ;
74326   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74327   unsigned int result;
74328
74329   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74330   result = (unsigned int) ((arg1)->end);
74331   jresult = result;
74332   return jresult;
74333 }
74334
74335
74336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
74337   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
74338
74339   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
74340   {
74341     try {
74342       delete arg1;
74343     } catch (std::out_of_range& e) {
74344       {
74345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74346       };
74347     } catch (std::exception& e) {
74348       {
74349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74350       };
74351     } catch (Dali::DaliException e) {
74352       {
74353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74354       };
74355     } catch (...) {
74356       {
74357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74358       };
74359     }
74360   }
74361
74362 }
74363
74364
74365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
74366   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74367
74368   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74369   {
74370     try {
74371       delete arg1;
74372     } catch (std::out_of_range& e) {
74373       {
74374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74375       };
74376     } catch (std::exception& e) {
74377       {
74378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74379       };
74380     } catch (Dali::DaliException e) {
74381       {
74382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74383       };
74384     } catch (...) {
74385       {
74386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74387       };
74388     }
74389   }
74390
74391 }
74392
74393
74394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
74395   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74396   Dali::Toolkit::ControlOrientation::Type arg2 ;
74397
74398   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74399   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
74400   {
74401     try {
74402       (arg1)->SetOrientation(arg2);
74403     } catch (std::out_of_range& e) {
74404       {
74405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74406       };
74407     } catch (std::exception& e) {
74408       {
74409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74410       };
74411     } catch (Dali::DaliException e) {
74412       {
74413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74414       };
74415     } catch (...) {
74416       {
74417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74418       };
74419     }
74420   }
74421
74422 }
74423
74424
74425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
74426   int jresult ;
74427   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74428   Dali::Toolkit::ControlOrientation::Type result;
74429
74430   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74431   {
74432     try {
74433       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
74434     } catch (std::out_of_range& e) {
74435       {
74436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74437       };
74438     } catch (std::exception& e) {
74439       {
74440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74441       };
74442     } catch (Dali::DaliException e) {
74443       {
74444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74445       };
74446     } catch (...) {
74447       {
74448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74449       };
74450     }
74451   }
74452
74453   jresult = (int)result;
74454   return jresult;
74455 }
74456
74457
74458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
74459   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74460   Dali::Property::Map *arg2 = 0 ;
74461
74462   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74463   arg2 = (Dali::Property::Map *)jarg2;
74464   if (!arg2) {
74465     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
74466     return ;
74467   }
74468   {
74469     try {
74470       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
74471     } catch (std::out_of_range& e) {
74472       {
74473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74474       };
74475     } catch (std::exception& e) {
74476       {
74477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74478       };
74479     } catch (Dali::DaliException e) {
74480       {
74481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74482       };
74483     } catch (...) {
74484       {
74485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74486       };
74487     }
74488   }
74489
74490 }
74491
74492
74493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
74494   void * jresult ;
74495   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74496   Dali::Property::Map result;
74497
74498   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74499   {
74500     try {
74501       result = (arg1)->GetLayoutProperties();
74502     } catch (std::out_of_range& e) {
74503       {
74504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74505       };
74506     } catch (std::exception& e) {
74507       {
74508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74509       };
74510     } catch (Dali::DaliException e) {
74511       {
74512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74513       };
74514     } catch (...) {
74515       {
74516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74517       };
74518     }
74519   }
74520
74521   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
74522   return jresult;
74523 }
74524
74525
74526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74527   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74528   unsigned int arg2 ;
74529   Dali::Vector3 *arg3 = 0 ;
74530   Dali::Vector3 *arg4 = 0 ;
74531
74532   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74533   arg2 = (unsigned int)jarg2;
74534   arg3 = (Dali::Vector3 *)jarg3;
74535   if (!arg3) {
74536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74537     return ;
74538   }
74539   arg4 = (Dali::Vector3 *)jarg4;
74540   if (!arg4) {
74541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74542     return ;
74543   }
74544   {
74545     try {
74546       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74547     } catch (std::out_of_range& e) {
74548       {
74549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74550       };
74551     } catch (std::exception& e) {
74552       {
74553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74554       };
74555     } catch (Dali::DaliException e) {
74556       {
74557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74558       };
74559     } catch (...) {
74560       {
74561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74562       };
74563     }
74564   }
74565
74566 }
74567
74568
74569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
74570   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74571   Dali::Vector3 *arg2 = 0 ;
74572
74573   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74574   arg2 = (Dali::Vector3 *)jarg2;
74575   if (!arg2) {
74576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74577     return ;
74578   }
74579   {
74580     try {
74581       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
74582     } catch (std::out_of_range& e) {
74583       {
74584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74585       };
74586     } catch (std::exception& e) {
74587       {
74588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74589       };
74590     } catch (Dali::DaliException e) {
74591       {
74592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74593       };
74594     } catch (...) {
74595       {
74596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74597       };
74598     }
74599   }
74600
74601 }
74602
74603
74604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
74605   float jresult ;
74606   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74607   unsigned int arg2 ;
74608   Dali::Vector3 arg3 ;
74609   Dali::Vector3 *argp3 ;
74610   float result;
74611
74612   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74613   arg2 = (unsigned int)jarg2;
74614   argp3 = (Dali::Vector3 *)jarg3;
74615   if (!argp3) {
74616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74617     return 0;
74618   }
74619   arg3 = *argp3;
74620   {
74621     try {
74622       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
74623     } catch (std::out_of_range& e) {
74624       {
74625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74626       };
74627     } catch (std::exception& e) {
74628       {
74629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74630       };
74631     } catch (Dali::DaliException e) {
74632       {
74633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74634       };
74635     } catch (...) {
74636       {
74637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74638       };
74639     }
74640   }
74641
74642   jresult = result;
74643   return jresult;
74644 }
74645
74646
74647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
74648   float jresult ;
74649   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74650   float arg2 ;
74651   float result;
74652
74653   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74654   arg2 = (float)jarg2;
74655   {
74656     try {
74657       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
74658     } catch (std::out_of_range& e) {
74659       {
74660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74661       };
74662     } catch (std::exception& e) {
74663       {
74664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74665       };
74666     } catch (Dali::DaliException e) {
74667       {
74668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74669       };
74670     } catch (...) {
74671       {
74672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74673       };
74674     }
74675   }
74676
74677   jresult = result;
74678   return jresult;
74679 }
74680
74681
74682 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
74683   float jresult ;
74684   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74685   unsigned int arg2 ;
74686   float result;
74687
74688   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74689   arg2 = (unsigned int)jarg2;
74690   {
74691     try {
74692       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
74693     } catch (std::out_of_range& e) {
74694       {
74695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74696       };
74697     } catch (std::exception& e) {
74698       {
74699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74700       };
74701     } catch (Dali::DaliException e) {
74702       {
74703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74704       };
74705     } catch (...) {
74706       {
74707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74708       };
74709     }
74710   }
74711
74712   jresult = result;
74713   return jresult;
74714 }
74715
74716
74717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
74718   void * jresult ;
74719   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74720   float arg2 ;
74721   Dali::Vector3 arg3 ;
74722   Dali::Vector3 *argp3 ;
74723   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
74724
74725   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74726   arg2 = (float)jarg2;
74727   argp3 = (Dali::Vector3 *)jarg3;
74728   if (!argp3) {
74729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74730     return 0;
74731   }
74732   arg3 = *argp3;
74733   {
74734     try {
74735       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
74736     } catch (std::out_of_range& e) {
74737       {
74738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74739       };
74740     } catch (std::exception& e) {
74741       {
74742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74743       };
74744     } catch (Dali::DaliException e) {
74745       {
74746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74747       };
74748     } catch (...) {
74749       {
74750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74751       };
74752     }
74753   }
74754
74755   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
74756   return jresult;
74757 }
74758
74759
74760 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
74761   float jresult ;
74762   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74763   int arg2 ;
74764   float arg3 ;
74765   Dali::Vector3 *arg4 = 0 ;
74766   float result;
74767
74768   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74769   arg2 = (int)jarg2;
74770   arg3 = (float)jarg3;
74771   arg4 = (Dali::Vector3 *)jarg4;
74772   if (!arg4) {
74773     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74774     return 0;
74775   }
74776   {
74777     try {
74778       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
74779     } catch (std::out_of_range& e) {
74780       {
74781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74782       };
74783     } catch (std::exception& e) {
74784       {
74785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74786       };
74787     } catch (Dali::DaliException e) {
74788       {
74789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74790       };
74791     } catch (...) {
74792       {
74793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74794       };
74795     }
74796   }
74797
74798   jresult = result;
74799   return jresult;
74800 }
74801
74802
74803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
74804   unsigned int jresult ;
74805   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74806   Dali::Vector3 arg2 ;
74807   Dali::Vector3 *argp2 ;
74808   unsigned int result;
74809
74810   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74811   argp2 = (Dali::Vector3 *)jarg2;
74812   if (!argp2) {
74813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
74814     return 0;
74815   }
74816   arg2 = *argp2;
74817   {
74818     try {
74819       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
74820     } catch (std::out_of_range& e) {
74821       {
74822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74823       };
74824     } catch (std::exception& e) {
74825       {
74826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74827       };
74828     } catch (Dali::DaliException e) {
74829       {
74830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74831       };
74832     } catch (...) {
74833       {
74834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74835       };
74836     }
74837   }
74838
74839   jresult = result;
74840   return jresult;
74841 }
74842
74843
74844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
74845   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74846   unsigned int arg2 ;
74847   Dali::Vector3 *arg3 = 0 ;
74848   Dali::Vector3 *arg4 = 0 ;
74849
74850   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74851   arg2 = (unsigned int)jarg2;
74852   arg3 = (Dali::Vector3 *)jarg3;
74853   if (!arg3) {
74854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74855     return ;
74856   }
74857   arg4 = (Dali::Vector3 *)jarg4;
74858   if (!arg4) {
74859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74860     return ;
74861   }
74862   {
74863     try {
74864       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
74865     } catch (std::out_of_range& e) {
74866       {
74867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74868       };
74869     } catch (std::exception& e) {
74870       {
74871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74872       };
74873     } catch (Dali::DaliException e) {
74874       {
74875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74876       };
74877     } catch (...) {
74878       {
74879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74880       };
74881     }
74882   }
74883
74884 }
74885
74886
74887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
74888   void * jresult ;
74889   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74890   Dali::Degree result;
74891
74892   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74893   {
74894     try {
74895       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
74896     } catch (std::out_of_range& e) {
74897       {
74898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74899       };
74900     } catch (std::exception& e) {
74901       {
74902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74903       };
74904     } catch (Dali::DaliException e) {
74905       {
74906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74907       };
74908     } catch (...) {
74909       {
74910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74911       };
74912     }
74913   }
74914
74915   jresult = new Dali::Degree((const Dali::Degree &)result);
74916   return jresult;
74917 }
74918
74919
74920 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
74921   float jresult ;
74922   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74923   float result;
74924
74925   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74926   {
74927     try {
74928       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
74929     } catch (std::out_of_range& e) {
74930       {
74931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74932       };
74933     } catch (std::exception& e) {
74934       {
74935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74936       };
74937     } catch (Dali::DaliException e) {
74938       {
74939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74940       };
74941     } catch (...) {
74942       {
74943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74944       };
74945     }
74946   }
74947
74948   jresult = result;
74949   return jresult;
74950 }
74951
74952
74953 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
74954   float jresult ;
74955   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74956   float result;
74957
74958   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74959   {
74960     try {
74961       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
74962     } catch (std::out_of_range& e) {
74963       {
74964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74965       };
74966     } catch (std::exception& e) {
74967       {
74968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74969       };
74970     } catch (Dali::DaliException e) {
74971       {
74972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74973       };
74974     } catch (...) {
74975       {
74976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74977       };
74978     }
74979   }
74980
74981   jresult = result;
74982   return jresult;
74983 }
74984
74985
74986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
74987   float jresult ;
74988   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
74989   float result;
74990
74991   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
74992   {
74993     try {
74994       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
74995     } catch (std::out_of_range& e) {
74996       {
74997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74998       };
74999     } catch (std::exception& e) {
75000       {
75001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75002       };
75003     } catch (Dali::DaliException e) {
75004       {
75005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75006       };
75007     } catch (...) {
75008       {
75009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75010       };
75011     }
75012   }
75013
75014   jresult = result;
75015   return jresult;
75016 }
75017
75018
75019 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
75020   int jresult ;
75021   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75022   int arg2 ;
75023   int arg3 ;
75024   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
75025   bool arg5 ;
75026   int result;
75027
75028   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75029   arg2 = (int)jarg2;
75030   arg3 = (int)jarg3;
75031   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
75032   arg5 = jarg5 ? true : false;
75033   {
75034     try {
75035       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
75036     } catch (std::out_of_range& e) {
75037       {
75038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75039       };
75040     } catch (std::exception& e) {
75041       {
75042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75043       };
75044     } catch (Dali::DaliException e) {
75045       {
75046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75047       };
75048     } catch (...) {
75049       {
75050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75051       };
75052     }
75053   }
75054
75055   jresult = result;
75056   return jresult;
75057 }
75058
75059
75060 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
75061   float jresult ;
75062   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75063   float result;
75064
75065   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75066   {
75067     try {
75068       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
75069     } catch (std::out_of_range& e) {
75070       {
75071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75072       };
75073     } catch (std::exception& e) {
75074       {
75075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75076       };
75077     } catch (Dali::DaliException e) {
75078       {
75079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75080       };
75081     } catch (...) {
75082       {
75083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75084       };
75085     }
75086   }
75087
75088   jresult = result;
75089   return jresult;
75090 }
75091
75092
75093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
75094   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75095   Dali::Actor *arg2 = 0 ;
75096   int arg3 ;
75097   Dali::Vector3 *arg4 = 0 ;
75098   Dali::Actor *arg5 = 0 ;
75099
75100   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75101   arg2 = (Dali::Actor *)jarg2;
75102   if (!arg2) {
75103     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
75104     return ;
75105   }
75106   arg3 = (int)jarg3;
75107   arg4 = (Dali::Vector3 *)jarg4;
75108   if (!arg4) {
75109     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75110     return ;
75111   }
75112   arg5 = (Dali::Actor *)jarg5;
75113   if (!arg5) {
75114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
75115     return ;
75116   }
75117   {
75118     try {
75119       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
75120     } catch (std::out_of_range& e) {
75121       {
75122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75123       };
75124     } catch (std::exception& e) {
75125       {
75126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75127       };
75128     } catch (Dali::DaliException e) {
75129       {
75130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75131       };
75132     } catch (...) {
75133       {
75134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75135       };
75136     }
75137   }
75138
75139 }
75140
75141
75142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
75143   void * jresult ;
75144   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
75145   int arg2 ;
75146   float arg3 ;
75147   Dali::Vector3 *arg4 = 0 ;
75148   Dali::Vector3 result;
75149
75150   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
75151   arg2 = (int)jarg2;
75152   arg3 = (float)jarg3;
75153   arg4 = (Dali::Vector3 *)jarg4;
75154   if (!arg4) {
75155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75156     return 0;
75157   }
75158   {
75159     try {
75160       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
75161     } catch (std::out_of_range& e) {
75162       {
75163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75164       };
75165     } catch (std::exception& e) {
75166       {
75167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75168       };
75169     } catch (Dali::DaliException e) {
75170       {
75171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75172       };
75173     } catch (...) {
75174       {
75175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75176       };
75177     }
75178   }
75179
75180   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
75181   return jresult;
75182 }
75183
75184
75185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
75186   void * jresult ;
75187   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
75188   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75189
75190   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
75191   {
75192     try {
75193       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
75194     } catch (std::out_of_range& e) {
75195       {
75196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75197       };
75198     } catch (std::exception& e) {
75199       {
75200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75201       };
75202     } catch (Dali::DaliException e) {
75203       {
75204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75205       };
75206     } catch (...) {
75207       {
75208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75209       };
75210     }
75211   }
75212
75213   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75214   return jresult;
75215 }
75216
75217
75218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
75219   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75220
75221   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75222   {
75223     try {
75224       delete arg1;
75225     } catch (std::out_of_range& e) {
75226       {
75227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75228       };
75229     } catch (std::exception& e) {
75230       {
75231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75232       };
75233     } catch (Dali::DaliException e) {
75234       {
75235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75236       };
75237     } catch (...) {
75238       {
75239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75240       };
75241     }
75242   }
75243
75244 }
75245
75246
75247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
75248   unsigned int jresult ;
75249   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75250   unsigned int result;
75251
75252   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75253   {
75254     try {
75255       result = (unsigned int)(arg1)->GetNumberOfItems();
75256     } catch (std::out_of_range& e) {
75257       {
75258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75259       };
75260     } catch (std::exception& e) {
75261       {
75262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75263       };
75264     } catch (Dali::DaliException e) {
75265       {
75266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75267       };
75268     } catch (...) {
75269       {
75270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75271       };
75272     }
75273   }
75274
75275   jresult = result;
75276   return jresult;
75277 }
75278
75279
75280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
75281   void * jresult ;
75282   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75283   unsigned int arg2 ;
75284   Dali::Actor result;
75285
75286   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75287   arg2 = (unsigned int)jarg2;
75288   {
75289     try {
75290       result = (arg1)->NewItem(arg2);
75291     } catch (std::out_of_range& e) {
75292       {
75293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75294       };
75295     } catch (std::exception& e) {
75296       {
75297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75298       };
75299     } catch (Dali::DaliException e) {
75300       {
75301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75302       };
75303     } catch (...) {
75304       {
75305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75306       };
75307     }
75308   }
75309
75310   jresult = new Dali::Actor((const Dali::Actor &)result);
75311   return jresult;
75312 }
75313
75314
75315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
75316   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75317   unsigned int arg2 ;
75318   Dali::Actor arg3 ;
75319   Dali::Actor *argp3 ;
75320
75321   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75322   arg2 = (unsigned int)jarg2;
75323   argp3 = (Dali::Actor *)jarg3;
75324   if (!argp3) {
75325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75326     return ;
75327   }
75328   arg3 = *argp3;
75329   {
75330     try {
75331       (arg1)->ItemReleased(arg2,arg3);
75332     } catch (std::out_of_range& e) {
75333       {
75334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75335       };
75336     } catch (std::exception& e) {
75337       {
75338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75339       };
75340     } catch (Dali::DaliException e) {
75341       {
75342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75343       };
75344     } catch (...) {
75345       {
75346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75347       };
75348     }
75349   }
75350
75351 }
75352
75353
75354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
75355   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
75356   unsigned int arg2 ;
75357   Dali::Actor arg3 ;
75358   Dali::Actor *argp3 ;
75359
75360   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75361   arg2 = (unsigned int)jarg2;
75362   argp3 = (Dali::Actor *)jarg3;
75363   if (!argp3) {
75364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75365     return ;
75366   }
75367   arg3 = *argp3;
75368   {
75369     try {
75370       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
75371     } catch (std::out_of_range& e) {
75372       {
75373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75374       };
75375     } catch (std::exception& e) {
75376       {
75377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75378       };
75379     } catch (Dali::DaliException e) {
75380       {
75381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75382       };
75383     } catch (...) {
75384       {
75385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75386       };
75387     }
75388   }
75389
75390 }
75391
75392
75393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
75394   void * jresult ;
75395   Dali::Toolkit::ItemFactory *result = 0 ;
75396
75397   {
75398     try {
75399       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
75400     } catch (std::out_of_range& e) {
75401       {
75402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75403       };
75404     } catch (std::exception& e) {
75405       {
75406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75407       };
75408     } catch (Dali::DaliException e) {
75409       {
75410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75411       };
75412     } catch (...) {
75413       {
75414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75415       };
75416     }
75417   }
75418
75419   jresult = (void *)result;
75420   return jresult;
75421 }
75422
75423
75424 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) {
75425   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
75426   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
75427   if (director) {
75428     director->swig_connect_director(callback0, callback1, callback2);
75429   }
75430 }
75431
75432
75433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
75434   int jresult ;
75435   int result;
75436
75437   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
75438   jresult = (int)result;
75439   return jresult;
75440 }
75441
75442
75443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
75444   int jresult ;
75445   int result;
75446
75447   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
75448   jresult = (int)result;
75449   return jresult;
75450 }
75451
75452
75453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
75454   int jresult ;
75455   int result;
75456
75457   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
75458   jresult = (int)result;
75459   return jresult;
75460 }
75461
75462
75463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
75464   int jresult ;
75465   int result;
75466
75467   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
75468   jresult = (int)result;
75469   return jresult;
75470 }
75471
75472
75473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
75474   int jresult ;
75475   int result;
75476
75477   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
75478   jresult = (int)result;
75479   return jresult;
75480 }
75481
75482
75483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
75484   int jresult ;
75485   int result;
75486
75487   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
75488   jresult = (int)result;
75489   return jresult;
75490 }
75491
75492
75493 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
75494   int jresult ;
75495   int result;
75496
75497   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
75498   jresult = (int)result;
75499   return jresult;
75500 }
75501
75502
75503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
75504   int jresult ;
75505   int result;
75506
75507   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
75508   jresult = (int)result;
75509   return jresult;
75510 }
75511
75512
75513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
75514   int jresult ;
75515   int result;
75516
75517   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
75518   jresult = (int)result;
75519   return jresult;
75520 }
75521
75522
75523 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
75524   int jresult ;
75525   int result;
75526
75527   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
75528   jresult = (int)result;
75529   return jresult;
75530 }
75531
75532
75533 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
75534   int jresult ;
75535   int result;
75536
75537   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
75538   jresult = (int)result;
75539   return jresult;
75540 }
75541
75542
75543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
75544   void * jresult ;
75545   Dali::Toolkit::ItemView::Property *result = 0 ;
75546
75547   {
75548     try {
75549       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
75550     } catch (std::out_of_range& e) {
75551       {
75552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75553       };
75554     } catch (std::exception& e) {
75555       {
75556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75557       };
75558     } catch (Dali::DaliException e) {
75559       {
75560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75561       };
75562     } catch (...) {
75563       {
75564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75565       };
75566     }
75567   }
75568
75569   jresult = (void *)result;
75570   return jresult;
75571 }
75572
75573
75574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
75575   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
75576
75577   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
75578   {
75579     try {
75580       delete arg1;
75581     } catch (std::out_of_range& e) {
75582       {
75583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75584       };
75585     } catch (std::exception& e) {
75586       {
75587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75588       };
75589     } catch (Dali::DaliException e) {
75590       {
75591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75592       };
75593     } catch (...) {
75594       {
75595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75596       };
75597     }
75598   }
75599
75600 }
75601
75602
75603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
75604   void * jresult ;
75605   Dali::Toolkit::ItemView *result = 0 ;
75606
75607   {
75608     try {
75609       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
75610     } catch (std::out_of_range& e) {
75611       {
75612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75613       };
75614     } catch (std::exception& e) {
75615       {
75616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75617       };
75618     } catch (Dali::DaliException e) {
75619       {
75620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75621       };
75622     } catch (...) {
75623       {
75624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75625       };
75626     }
75627   }
75628
75629   jresult = (void *)result;
75630   return jresult;
75631 }
75632
75633
75634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
75635   void * jresult ;
75636   Dali::Toolkit::ItemView *arg1 = 0 ;
75637   Dali::Toolkit::ItemView *result = 0 ;
75638
75639   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75640   if (!arg1) {
75641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75642     return 0;
75643   }
75644   {
75645     try {
75646       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
75647     } catch (std::out_of_range& e) {
75648       {
75649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75650       };
75651     } catch (std::exception& e) {
75652       {
75653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75654       };
75655     } catch (Dali::DaliException e) {
75656       {
75657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75658       };
75659     } catch (...) {
75660       {
75661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75662       };
75663     }
75664   }
75665
75666   jresult = (void *)result;
75667   return jresult;
75668 }
75669
75670
75671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
75672   void * jresult ;
75673   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75674   Dali::Toolkit::ItemView *arg2 = 0 ;
75675   Dali::Toolkit::ItemView *result = 0 ;
75676
75677   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75678   arg2 = (Dali::Toolkit::ItemView *)jarg2;
75679   if (!arg2) {
75680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
75681     return 0;
75682   }
75683   {
75684     try {
75685       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
75686     } catch (std::out_of_range& e) {
75687       {
75688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75689       };
75690     } catch (std::exception& e) {
75691       {
75692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75693       };
75694     } catch (Dali::DaliException e) {
75695       {
75696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75697       };
75698     } catch (...) {
75699       {
75700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75701       };
75702     }
75703   }
75704
75705   jresult = (void *)result;
75706   return jresult;
75707 }
75708
75709
75710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
75711   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75712
75713   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75714   {
75715     try {
75716       delete arg1;
75717     } catch (std::out_of_range& e) {
75718       {
75719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75720       };
75721     } catch (std::exception& e) {
75722       {
75723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75724       };
75725     } catch (Dali::DaliException e) {
75726       {
75727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75728       };
75729     } catch (...) {
75730       {
75731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75732       };
75733     }
75734   }
75735
75736 }
75737
75738
75739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
75740   void * jresult ;
75741   Dali::Toolkit::ItemFactory *arg1 = 0 ;
75742   Dali::Toolkit::ItemView result;
75743
75744   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
75745   if (!arg1) {
75746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
75747     return 0;
75748   }
75749   {
75750     try {
75751       result = Dali::Toolkit::ItemView::New(*arg1);
75752     } catch (std::out_of_range& e) {
75753       {
75754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75755       };
75756     } catch (std::exception& e) {
75757       {
75758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75759       };
75760     } catch (Dali::DaliException e) {
75761       {
75762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75763       };
75764     } catch (...) {
75765       {
75766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75767       };
75768     }
75769   }
75770
75771   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75772   return jresult;
75773 }
75774
75775
75776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
75777   void * jresult ;
75778   Dali::BaseHandle arg1 ;
75779   Dali::BaseHandle *argp1 ;
75780   Dali::Toolkit::ItemView result;
75781
75782   argp1 = (Dali::BaseHandle *)jarg1;
75783   if (!argp1) {
75784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75785     return 0;
75786   }
75787   arg1 = *argp1;
75788   {
75789     try {
75790       result = Dali::Toolkit::ItemView::DownCast(arg1);
75791     } catch (std::out_of_range& e) {
75792       {
75793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75794       };
75795     } catch (std::exception& e) {
75796       {
75797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75798       };
75799     } catch (Dali::DaliException e) {
75800       {
75801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75802       };
75803     } catch (...) {
75804       {
75805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75806       };
75807     }
75808   }
75809
75810   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
75811   return jresult;
75812 }
75813
75814
75815 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
75816   unsigned int jresult ;
75817   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75818   unsigned int result;
75819
75820   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75821   {
75822     try {
75823       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
75824     } catch (std::out_of_range& e) {
75825       {
75826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75827       };
75828     } catch (std::exception& e) {
75829       {
75830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75831       };
75832     } catch (Dali::DaliException e) {
75833       {
75834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75835       };
75836     } catch (...) {
75837       {
75838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75839       };
75840     }
75841   }
75842
75843   jresult = result;
75844   return jresult;
75845 }
75846
75847
75848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
75849   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75850   Dali::Toolkit::ItemLayout *arg2 = 0 ;
75851
75852   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75853   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
75854   if (!arg2) {
75855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
75856     return ;
75857   }
75858   {
75859     try {
75860       (arg1)->AddLayout(*arg2);
75861     } catch (std::out_of_range& e) {
75862       {
75863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75864       };
75865     } catch (std::exception& e) {
75866       {
75867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75868       };
75869     } catch (Dali::DaliException e) {
75870       {
75871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75872       };
75873     } catch (...) {
75874       {
75875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75876       };
75877     }
75878   }
75879
75880 }
75881
75882
75883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
75884   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75885   unsigned int arg2 ;
75886
75887   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75888   arg2 = (unsigned int)jarg2;
75889   {
75890     try {
75891       (arg1)->RemoveLayout(arg2);
75892     } catch (std::out_of_range& e) {
75893       {
75894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75895       };
75896     } catch (std::exception& e) {
75897       {
75898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75899       };
75900     } catch (Dali::DaliException e) {
75901       {
75902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75903       };
75904     } catch (...) {
75905       {
75906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75907       };
75908     }
75909   }
75910
75911 }
75912
75913
75914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
75915   void * jresult ;
75916   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75917   unsigned int arg2 ;
75918   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75919
75920   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75921   arg2 = (unsigned int)jarg2;
75922   {
75923     try {
75924       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
75925     } catch (std::out_of_range& e) {
75926       {
75927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75928       };
75929     } catch (std::exception& e) {
75930       {
75931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75932       };
75933     } catch (Dali::DaliException e) {
75934       {
75935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75936       };
75937     } catch (...) {
75938       {
75939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75940       };
75941     }
75942   }
75943
75944   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75945   return jresult;
75946 }
75947
75948
75949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
75950   void * jresult ;
75951   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75952   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
75953
75954   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75955   {
75956     try {
75957       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
75958     } catch (std::out_of_range& e) {
75959       {
75960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75961       };
75962     } catch (std::exception& e) {
75963       {
75964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75965       };
75966     } catch (Dali::DaliException e) {
75967       {
75968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75969       };
75970     } catch (...) {
75971       {
75972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75973       };
75974     }
75975   }
75976
75977   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
75978   return jresult;
75979 }
75980
75981
75982 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
75983   float jresult ;
75984   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
75985   Dali::Toolkit::ItemId arg2 ;
75986   float result;
75987
75988   arg1 = (Dali::Toolkit::ItemView *)jarg1;
75989   arg2 = (Dali::Toolkit::ItemId)jarg2;
75990   {
75991     try {
75992       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
75993     } catch (std::out_of_range& e) {
75994       {
75995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75996       };
75997     } catch (std::exception& e) {
75998       {
75999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76000       };
76001     } catch (Dali::DaliException e) {
76002       {
76003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76004       };
76005     } catch (...) {
76006       {
76007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76008       };
76009     }
76010   }
76011
76012   jresult = result;
76013   return jresult;
76014 }
76015
76016
76017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
76018   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76019   unsigned int arg2 ;
76020   Dali::Vector3 arg3 ;
76021   float arg4 ;
76022   Dali::Vector3 *argp3 ;
76023
76024   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76025   arg2 = (unsigned int)jarg2;
76026   argp3 = (Dali::Vector3 *)jarg3;
76027   if (!argp3) {
76028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
76029     return ;
76030   }
76031   arg3 = *argp3;
76032   arg4 = (float)jarg4;
76033   {
76034     try {
76035       (arg1)->ActivateLayout(arg2,arg3,arg4);
76036     } catch (std::out_of_range& e) {
76037       {
76038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76039       };
76040     } catch (std::exception& e) {
76041       {
76042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76043       };
76044     } catch (Dali::DaliException e) {
76045       {
76046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76047       };
76048     } catch (...) {
76049       {
76050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76051       };
76052     }
76053   }
76054
76055 }
76056
76057
76058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
76059   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76060
76061   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76062   {
76063     try {
76064       (arg1)->DeactivateCurrentLayout();
76065     } catch (std::out_of_range& e) {
76066       {
76067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76068       };
76069     } catch (std::exception& e) {
76070       {
76071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76072       };
76073     } catch (Dali::DaliException e) {
76074       {
76075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76076       };
76077     } catch (...) {
76078       {
76079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76080       };
76081     }
76082   }
76083
76084 }
76085
76086
76087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
76088   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76089   float arg2 ;
76090
76091   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76092   arg2 = (float)jarg2;
76093   {
76094     try {
76095       (arg1)->SetMinimumSwipeSpeed(arg2);
76096     } catch (std::out_of_range& e) {
76097       {
76098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76099       };
76100     } catch (std::exception& e) {
76101       {
76102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76103       };
76104     } catch (Dali::DaliException e) {
76105       {
76106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76107       };
76108     } catch (...) {
76109       {
76110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76111       };
76112     }
76113   }
76114
76115 }
76116
76117
76118 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
76119   float jresult ;
76120   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76121   float result;
76122
76123   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76124   {
76125     try {
76126       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
76127     } catch (std::out_of_range& e) {
76128       {
76129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76130       };
76131     } catch (std::exception& e) {
76132       {
76133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76134       };
76135     } catch (Dali::DaliException e) {
76136       {
76137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76138       };
76139     } catch (...) {
76140       {
76141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76142       };
76143     }
76144   }
76145
76146   jresult = result;
76147   return jresult;
76148 }
76149
76150
76151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
76152   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76153   float arg2 ;
76154
76155   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76156   arg2 = (float)jarg2;
76157   {
76158     try {
76159       (arg1)->SetMinimumSwipeDistance(arg2);
76160     } catch (std::out_of_range& e) {
76161       {
76162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76163       };
76164     } catch (std::exception& e) {
76165       {
76166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76167       };
76168     } catch (Dali::DaliException e) {
76169       {
76170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76171       };
76172     } catch (...) {
76173       {
76174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76175       };
76176     }
76177   }
76178
76179 }
76180
76181
76182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
76183   float jresult ;
76184   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76185   float result;
76186
76187   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76188   {
76189     try {
76190       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
76191     } catch (std::out_of_range& e) {
76192       {
76193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76194       };
76195     } catch (std::exception& e) {
76196       {
76197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76198       };
76199     } catch (Dali::DaliException e) {
76200       {
76201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76202       };
76203     } catch (...) {
76204       {
76205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76206       };
76207     }
76208   }
76209
76210   jresult = result;
76211   return jresult;
76212 }
76213
76214
76215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
76216   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76217   float arg2 ;
76218
76219   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76220   arg2 = (float)jarg2;
76221   {
76222     try {
76223       (arg1)->SetWheelScrollDistanceStep(arg2);
76224     } catch (std::out_of_range& e) {
76225       {
76226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76227       };
76228     } catch (std::exception& e) {
76229       {
76230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76231       };
76232     } catch (Dali::DaliException e) {
76233       {
76234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76235       };
76236     } catch (...) {
76237       {
76238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76239       };
76240     }
76241   }
76242
76243 }
76244
76245
76246 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
76247   float jresult ;
76248   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76249   float result;
76250
76251   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76252   {
76253     try {
76254       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
76255     } catch (std::out_of_range& e) {
76256       {
76257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76258       };
76259     } catch (std::exception& e) {
76260       {
76261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76262       };
76263     } catch (Dali::DaliException e) {
76264       {
76265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76266       };
76267     } catch (...) {
76268       {
76269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76270       };
76271     }
76272   }
76273
76274   jresult = result;
76275   return jresult;
76276 }
76277
76278
76279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
76280   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76281   bool arg2 ;
76282
76283   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76284   arg2 = jarg2 ? true : false;
76285   {
76286     try {
76287       (arg1)->SetAnchoring(arg2);
76288     } catch (std::out_of_range& e) {
76289       {
76290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76291       };
76292     } catch (std::exception& e) {
76293       {
76294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76295       };
76296     } catch (Dali::DaliException e) {
76297       {
76298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76299       };
76300     } catch (...) {
76301       {
76302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76303       };
76304     }
76305   }
76306
76307 }
76308
76309 //// ========================= end of part 3 =============================
76310
76311 //// ========================== start part 4 ===============================
76312
76313
76314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
76315   unsigned int jresult ;
76316   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76317   bool result;
76318
76319   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76320   {
76321     try {
76322       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
76323     } catch (std::out_of_range& e) {
76324       {
76325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76326       };
76327     } catch (std::exception& e) {
76328       {
76329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76330       };
76331     } catch (Dali::DaliException e) {
76332       {
76333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76334       };
76335     } catch (...) {
76336       {
76337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76338       };
76339     }
76340   }
76341
76342   jresult = result;
76343   return jresult;
76344 }
76345
76346
76347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
76348   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76349   float arg2 ;
76350
76351   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76352   arg2 = (float)jarg2;
76353   {
76354     try {
76355       (arg1)->SetAnchoringDuration(arg2);
76356     } catch (std::out_of_range& e) {
76357       {
76358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76359       };
76360     } catch (std::exception& e) {
76361       {
76362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76363       };
76364     } catch (Dali::DaliException e) {
76365       {
76366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76367       };
76368     } catch (...) {
76369       {
76370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76371       };
76372     }
76373   }
76374
76375 }
76376
76377
76378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
76379   float jresult ;
76380   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76381   float result;
76382
76383   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76384   {
76385     try {
76386       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
76387     } catch (std::out_of_range& e) {
76388       {
76389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76390       };
76391     } catch (std::exception& e) {
76392       {
76393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76394       };
76395     } catch (Dali::DaliException e) {
76396       {
76397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76398       };
76399     } catch (...) {
76400       {
76401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76402       };
76403     }
76404   }
76405
76406   jresult = result;
76407   return jresult;
76408 }
76409
76410
76411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
76412   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76413   Dali::Toolkit::ItemId arg2 ;
76414   float arg3 ;
76415
76416   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76417   arg2 = (Dali::Toolkit::ItemId)jarg2;
76418   arg3 = (float)jarg3;
76419   {
76420     try {
76421       (arg1)->ScrollToItem(arg2,arg3);
76422     } catch (std::out_of_range& e) {
76423       {
76424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76425       };
76426     } catch (std::exception& e) {
76427       {
76428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76429       };
76430     } catch (Dali::DaliException e) {
76431       {
76432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76433       };
76434     } catch (...) {
76435       {
76436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76437       };
76438     }
76439   }
76440
76441 }
76442
76443
76444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
76445   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76446   float arg2 ;
76447
76448   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76449   arg2 = (float)jarg2;
76450   {
76451     try {
76452       (arg1)->SetRefreshInterval(arg2);
76453     } catch (std::out_of_range& e) {
76454       {
76455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76456       };
76457     } catch (std::exception& e) {
76458       {
76459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76460       };
76461     } catch (Dali::DaliException e) {
76462       {
76463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76464       };
76465     } catch (...) {
76466       {
76467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76468       };
76469     }
76470   }
76471
76472 }
76473
76474
76475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
76476   float jresult ;
76477   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76478   float result;
76479
76480   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76481   {
76482     try {
76483       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
76484     } catch (std::out_of_range& e) {
76485       {
76486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76487       };
76488     } catch (std::exception& e) {
76489       {
76490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76491       };
76492     } catch (Dali::DaliException e) {
76493       {
76494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76495       };
76496     } catch (...) {
76497       {
76498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76499       };
76500     }
76501   }
76502
76503   jresult = result;
76504   return jresult;
76505 }
76506
76507
76508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
76509   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76510
76511   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76512   {
76513     try {
76514       (arg1)->Refresh();
76515     } catch (std::out_of_range& e) {
76516       {
76517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76518       };
76519     } catch (std::exception& e) {
76520       {
76521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76522       };
76523     } catch (Dali::DaliException e) {
76524       {
76525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76526       };
76527     } catch (...) {
76528       {
76529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76530       };
76531     }
76532   }
76533
76534 }
76535
76536
76537 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
76538   void * jresult ;
76539   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76540   Dali::Toolkit::ItemId arg2 ;
76541   Dali::Actor result;
76542
76543   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76544   arg2 = (Dali::Toolkit::ItemId)jarg2;
76545   {
76546     try {
76547       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
76548     } catch (std::out_of_range& e) {
76549       {
76550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76551       };
76552     } catch (std::exception& e) {
76553       {
76554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76555       };
76556     } catch (Dali::DaliException e) {
76557       {
76558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76559       };
76560     } catch (...) {
76561       {
76562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76563       };
76564     }
76565   }
76566
76567   jresult = new Dali::Actor((const Dali::Actor &)result);
76568   return jresult;
76569 }
76570
76571
76572 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
76573   unsigned int jresult ;
76574   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76575   Dali::Actor arg2 ;
76576   Dali::Actor *argp2 ;
76577   Dali::Toolkit::ItemId result;
76578
76579   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76580   argp2 = (Dali::Actor *)jarg2;
76581   if (!argp2) {
76582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76583     return 0;
76584   }
76585   arg2 = *argp2;
76586   {
76587     try {
76588       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
76589     } catch (std::out_of_range& e) {
76590       {
76591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76592       };
76593     } catch (std::exception& e) {
76594       {
76595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76596       };
76597     } catch (Dali::DaliException e) {
76598       {
76599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76600       };
76601     } catch (...) {
76602       {
76603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76604       };
76605     }
76606   }
76607
76608   jresult = result;
76609   return jresult;
76610 }
76611
76612
76613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
76614   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76615   Dali::Toolkit::Item arg2 ;
76616   float arg3 ;
76617   Dali::Toolkit::Item *argp2 ;
76618
76619   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76620   argp2 = (Dali::Toolkit::Item *)jarg2;
76621   if (!argp2) {
76622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76623     return ;
76624   }
76625   arg2 = *argp2;
76626   arg3 = (float)jarg3;
76627   {
76628     try {
76629       (arg1)->InsertItem(arg2,arg3);
76630     } catch (std::out_of_range& e) {
76631       {
76632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76633       };
76634     } catch (std::exception& e) {
76635       {
76636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76637       };
76638     } catch (Dali::DaliException e) {
76639       {
76640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76641       };
76642     } catch (...) {
76643       {
76644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76645       };
76646     }
76647   }
76648
76649 }
76650
76651
76652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
76653   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76654   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76655   float arg3 ;
76656
76657   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76658   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76659   if (!arg2) {
76660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76661     return ;
76662   }
76663   arg3 = (float)jarg3;
76664   {
76665     try {
76666       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76667     } catch (std::out_of_range& e) {
76668       {
76669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76670       };
76671     } catch (std::exception& e) {
76672       {
76673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76674       };
76675     } catch (Dali::DaliException e) {
76676       {
76677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76678       };
76679     } catch (...) {
76680       {
76681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76682       };
76683     }
76684   }
76685
76686 }
76687
76688
76689 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
76690   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76691   Dali::Toolkit::ItemId arg2 ;
76692   float arg3 ;
76693
76694   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76695   arg2 = (Dali::Toolkit::ItemId)jarg2;
76696   arg3 = (float)jarg3;
76697   {
76698     try {
76699       (arg1)->RemoveItem(arg2,arg3);
76700     } catch (std::out_of_range& e) {
76701       {
76702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76703       };
76704     } catch (std::exception& e) {
76705       {
76706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76707       };
76708     } catch (Dali::DaliException e) {
76709       {
76710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76711       };
76712     } catch (...) {
76713       {
76714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76715       };
76716     }
76717   }
76718
76719 }
76720
76721
76722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
76723   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76724   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
76725   float arg3 ;
76726
76727   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76728   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
76729   if (!arg2) {
76730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
76731     return ;
76732   }
76733   arg3 = (float)jarg3;
76734   {
76735     try {
76736       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
76737     } catch (std::out_of_range& e) {
76738       {
76739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76740       };
76741     } catch (std::exception& e) {
76742       {
76743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76744       };
76745     } catch (Dali::DaliException e) {
76746       {
76747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76748       };
76749     } catch (...) {
76750       {
76751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76752       };
76753     }
76754   }
76755
76756 }
76757
76758
76759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
76760   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76761   Dali::Toolkit::Item arg2 ;
76762   float arg3 ;
76763   Dali::Toolkit::Item *argp2 ;
76764
76765   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76766   argp2 = (Dali::Toolkit::Item *)jarg2;
76767   if (!argp2) {
76768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
76769     return ;
76770   }
76771   arg2 = *argp2;
76772   arg3 = (float)jarg3;
76773   {
76774     try {
76775       (arg1)->ReplaceItem(arg2,arg3);
76776     } catch (std::out_of_range& e) {
76777       {
76778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76779       };
76780     } catch (std::exception& e) {
76781       {
76782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76783       };
76784     } catch (Dali::DaliException e) {
76785       {
76786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76787       };
76788     } catch (...) {
76789       {
76790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76791       };
76792     }
76793   }
76794
76795 }
76796
76797
76798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
76799   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76800   Dali::Toolkit::ItemContainer *arg2 = 0 ;
76801   float arg3 ;
76802
76803   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76804   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
76805   if (!arg2) {
76806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
76807     return ;
76808   }
76809   arg3 = (float)jarg3;
76810   {
76811     try {
76812       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
76813     } catch (std::out_of_range& e) {
76814       {
76815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76816       };
76817     } catch (std::exception& e) {
76818       {
76819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76820       };
76821     } catch (Dali::DaliException e) {
76822       {
76823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76824       };
76825     } catch (...) {
76826       {
76827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76828       };
76829     }
76830   }
76831
76832 }
76833
76834
76835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
76836   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76837   Dali::Vector3 *arg2 = 0 ;
76838
76839   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76840   arg2 = (Dali::Vector3 *)jarg2;
76841   if (!arg2) {
76842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76843     return ;
76844   }
76845   {
76846     try {
76847       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
76848     } catch (std::out_of_range& e) {
76849       {
76850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76851       };
76852     } catch (std::exception& e) {
76853       {
76854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76855       };
76856     } catch (Dali::DaliException e) {
76857       {
76858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76859       };
76860     } catch (...) {
76861       {
76862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76863       };
76864     }
76865   }
76866
76867 }
76868
76869
76870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
76871   void * jresult ;
76872   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76873   Dali::Vector3 result;
76874
76875   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76876   {
76877     try {
76878       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
76879     } catch (std::out_of_range& e) {
76880       {
76881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76882       };
76883     } catch (std::exception& e) {
76884       {
76885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76886       };
76887     } catch (Dali::DaliException e) {
76888       {
76889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76890       };
76891     } catch (...) {
76892       {
76893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76894       };
76895     }
76896   }
76897
76898   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76899   return jresult;
76900 }
76901
76902
76903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
76904   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76905   Dali::Vector3 *arg2 = 0 ;
76906
76907   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76908   arg2 = (Dali::Vector3 *)jarg2;
76909   if (!arg2) {
76910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
76911     return ;
76912   }
76913   {
76914     try {
76915       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
76916     } catch (std::out_of_range& e) {
76917       {
76918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76919       };
76920     } catch (std::exception& e) {
76921       {
76922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76923       };
76924     } catch (Dali::DaliException e) {
76925       {
76926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76927       };
76928     } catch (...) {
76929       {
76930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76931       };
76932     }
76933   }
76934
76935 }
76936
76937
76938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
76939   void * jresult ;
76940   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76941   Dali::Vector3 result;
76942
76943   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76944   {
76945     try {
76946       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
76947     } catch (std::out_of_range& e) {
76948       {
76949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76950       };
76951     } catch (std::exception& e) {
76952       {
76953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76954       };
76955     } catch (Dali::DaliException e) {
76956       {
76957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76958       };
76959     } catch (...) {
76960       {
76961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76962       };
76963     }
76964   }
76965
76966   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
76967   return jresult;
76968 }
76969
76970
76971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
76972   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
76973   Dali::Toolkit::ItemRange *arg2 = 0 ;
76974
76975   arg1 = (Dali::Toolkit::ItemView *)jarg1;
76976   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
76977   if (!arg2) {
76978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
76979     return ;
76980   }
76981   {
76982     try {
76983       (arg1)->GetItemsRange(*arg2);
76984     } catch (std::out_of_range& e) {
76985       {
76986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76987       };
76988     } catch (std::exception& e) {
76989       {
76990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76991       };
76992     } catch (Dali::DaliException e) {
76993       {
76994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76995       };
76996     } catch (...) {
76997       {
76998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76999       };
77000     }
77001   }
77002
77003 }
77004
77005
77006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
77007   void * jresult ;
77008   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
77009   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
77010
77011   arg1 = (Dali::Toolkit::ItemView *)jarg1;
77012   {
77013     try {
77014       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
77015     } catch (std::out_of_range& e) {
77016       {
77017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77018       };
77019     } catch (std::exception& e) {
77020       {
77021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77022       };
77023     } catch (Dali::DaliException e) {
77024       {
77025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77026       };
77027     } catch (...) {
77028       {
77029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77030       };
77031     }
77032   }
77033
77034   jresult = (void *)result;
77035   return jresult;
77036 }
77037
77038
77039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
77040   Dali::Vector3 *arg1 = 0 ;
77041   PropertyInputContainer *arg2 = 0 ;
77042
77043   arg1 = (Dali::Vector3 *)jarg1;
77044   if (!arg1) {
77045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77046     return ;
77047   }
77048   arg2 = (PropertyInputContainer *)jarg2;
77049   if (!arg2) {
77050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77051     return ;
77052   }
77053   {
77054     try {
77055       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77056     } catch (std::out_of_range& e) {
77057       {
77058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77059       };
77060     } catch (std::exception& e) {
77061       {
77062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77063       };
77064     } catch (Dali::DaliException e) {
77065       {
77066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77067       };
77068     } catch (...) {
77069       {
77070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77071       };
77072     }
77073   }
77074
77075 }
77076
77077
77078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
77079   Dali::Vector3 *arg1 = 0 ;
77080   PropertyInputContainer *arg2 = 0 ;
77081
77082   arg1 = (Dali::Vector3 *)jarg1;
77083   if (!arg1) {
77084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
77085     return ;
77086   }
77087   arg2 = (PropertyInputContainer *)jarg2;
77088   if (!arg2) {
77089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
77090     return ;
77091   }
77092   {
77093     try {
77094       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
77095     } catch (std::out_of_range& e) {
77096       {
77097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77098       };
77099     } catch (std::exception& e) {
77100       {
77101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77102       };
77103     } catch (Dali::DaliException e) {
77104       {
77105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77106       };
77107     } catch (...) {
77108       {
77109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77110       };
77111     }
77112   }
77113
77114 }
77115
77116
77117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
77118   void * jresult ;
77119   Dali::Toolkit::ScrollViewEffect *result = 0 ;
77120
77121   {
77122     try {
77123       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
77124     } catch (std::out_of_range& e) {
77125       {
77126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77127       };
77128     } catch (std::exception& e) {
77129       {
77130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77131       };
77132     } catch (Dali::DaliException e) {
77133       {
77134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77135       };
77136     } catch (...) {
77137       {
77138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77139       };
77140     }
77141   }
77142
77143   jresult = (void *)result;
77144   return jresult;
77145 }
77146
77147
77148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
77149   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
77150
77151   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
77152   {
77153     try {
77154       delete arg1;
77155     } catch (std::out_of_range& e) {
77156       {
77157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77158       };
77159     } catch (std::exception& e) {
77160       {
77161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77162       };
77163     } catch (Dali::DaliException e) {
77164       {
77165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77166       };
77167     } catch (...) {
77168       {
77169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77170       };
77171     }
77172   }
77173
77174 }
77175
77176
77177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
77178   void * jresult ;
77179   Dali::Path arg1 ;
77180   Dali::Vector3 *arg2 = 0 ;
77181   Dali::Property::Index arg3 ;
77182   Dali::Vector3 *arg4 = 0 ;
77183   unsigned int arg5 ;
77184   Dali::Path *argp1 ;
77185   Dali::Toolkit::ScrollViewPagePathEffect result;
77186
77187   argp1 = (Dali::Path *)jarg1;
77188   if (!argp1) {
77189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
77190     return 0;
77191   }
77192   arg1 = *argp1;
77193   arg2 = (Dali::Vector3 *)jarg2;
77194   if (!arg2) {
77195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77196     return 0;
77197   }
77198   arg3 = (Dali::Property::Index)jarg3;
77199   arg4 = (Dali::Vector3 *)jarg4;
77200   if (!arg4) {
77201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
77202     return 0;
77203   }
77204   arg5 = (unsigned int)jarg5;
77205   {
77206     try {
77207       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
77208     } catch (std::out_of_range& e) {
77209       {
77210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77211       };
77212     } catch (std::exception& e) {
77213       {
77214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77215       };
77216     } catch (Dali::DaliException e) {
77217       {
77218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77219       };
77220     } catch (...) {
77221       {
77222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77223       };
77224     }
77225   }
77226
77227   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77228   return jresult;
77229 }
77230
77231
77232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
77233   void * jresult ;
77234   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
77235
77236   {
77237     try {
77238       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
77239     } catch (std::out_of_range& e) {
77240       {
77241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77242       };
77243     } catch (std::exception& e) {
77244       {
77245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77246       };
77247     } catch (Dali::DaliException e) {
77248       {
77249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77250       };
77251     } catch (...) {
77252       {
77253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77254       };
77255     }
77256   }
77257
77258   jresult = (void *)result;
77259   return jresult;
77260 }
77261
77262
77263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
77264   void * jresult ;
77265   Dali::BaseHandle arg1 ;
77266   Dali::BaseHandle *argp1 ;
77267   Dali::Toolkit::ScrollViewPagePathEffect result;
77268
77269   argp1 = (Dali::BaseHandle *)jarg1;
77270   if (!argp1) {
77271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77272     return 0;
77273   }
77274   arg1 = *argp1;
77275   {
77276     try {
77277       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
77278     } catch (std::out_of_range& e) {
77279       {
77280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77281       };
77282     } catch (std::exception& e) {
77283       {
77284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77285       };
77286     } catch (Dali::DaliException e) {
77287       {
77288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77289       };
77290     } catch (...) {
77291       {
77292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77293       };
77294     }
77295   }
77296
77297   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
77298   return jresult;
77299 }
77300
77301
77302 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
77303   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77304   Dali::Actor arg2 ;
77305   unsigned int arg3 ;
77306   Dali::Actor *argp2 ;
77307
77308   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77309   argp2 = (Dali::Actor *)jarg2;
77310   if (!argp2) {
77311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77312     return ;
77313   }
77314   arg2 = *argp2;
77315   arg3 = (unsigned int)jarg3;
77316   {
77317     try {
77318       (arg1)->ApplyToPage(arg2,arg3);
77319     } catch (std::out_of_range& e) {
77320       {
77321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77322       };
77323     } catch (std::exception& e) {
77324       {
77325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77326       };
77327     } catch (Dali::DaliException e) {
77328       {
77329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77330       };
77331     } catch (...) {
77332       {
77333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77334       };
77335     }
77336   }
77337
77338 }
77339
77340
77341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
77342   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
77343
77344   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
77345   {
77346     try {
77347       delete arg1;
77348     } catch (std::out_of_range& e) {
77349       {
77350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77351       };
77352     } catch (std::exception& e) {
77353       {
77354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77355       };
77356     } catch (Dali::DaliException e) {
77357       {
77358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77359       };
77360     } catch (...) {
77361       {
77362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77363       };
77364     }
77365   }
77366
77367 }
77368
77369
77370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
77371   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77372   Dali::Toolkit::ClampState arg2 ;
77373
77374   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77375   arg2 = (Dali::Toolkit::ClampState)jarg2;
77376   if (arg1) (arg1)->x = arg2;
77377 }
77378
77379
77380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
77381   int jresult ;
77382   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77383   Dali::Toolkit::ClampState result;
77384
77385   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77386   result = (Dali::Toolkit::ClampState) ((arg1)->x);
77387   jresult = (int)result;
77388   return jresult;
77389 }
77390
77391
77392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
77393   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77394   Dali::Toolkit::ClampState arg2 ;
77395
77396   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77397   arg2 = (Dali::Toolkit::ClampState)jarg2;
77398   if (arg1) (arg1)->y = arg2;
77399 }
77400
77401
77402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
77403   int jresult ;
77404   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77405   Dali::Toolkit::ClampState result;
77406
77407   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77408   result = (Dali::Toolkit::ClampState) ((arg1)->y);
77409   jresult = (int)result;
77410   return jresult;
77411 }
77412
77413
77414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
77415   void * jresult ;
77416   Dali::Toolkit::ClampState2D *result = 0 ;
77417
77418   {
77419     try {
77420       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
77421     } catch (std::out_of_range& e) {
77422       {
77423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77424       };
77425     } catch (std::exception& e) {
77426       {
77427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77428       };
77429     } catch (Dali::DaliException e) {
77430       {
77431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77432       };
77433     } catch (...) {
77434       {
77435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77436       };
77437     }
77438   }
77439
77440   jresult = (void *)result;
77441   return jresult;
77442 }
77443
77444
77445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
77446   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
77447
77448   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
77449   {
77450     try {
77451       delete arg1;
77452     } catch (std::out_of_range& e) {
77453       {
77454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77455       };
77456     } catch (std::exception& e) {
77457       {
77458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77459       };
77460     } catch (Dali::DaliException e) {
77461       {
77462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77463       };
77464     } catch (...) {
77465       {
77466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77467       };
77468     }
77469   }
77470
77471 }
77472
77473
77474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
77475   void * jresult ;
77476   float arg1 ;
77477   float arg2 ;
77478   bool arg3 ;
77479   Dali::Toolkit::RulerDomain *result = 0 ;
77480
77481   arg1 = (float)jarg1;
77482   arg2 = (float)jarg2;
77483   arg3 = jarg3 ? true : false;
77484   {
77485     try {
77486       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
77487     } catch (std::out_of_range& e) {
77488       {
77489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77490       };
77491     } catch (std::exception& e) {
77492       {
77493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77494       };
77495     } catch (Dali::DaliException e) {
77496       {
77497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77498       };
77499     } catch (...) {
77500       {
77501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77502       };
77503     }
77504   }
77505
77506   jresult = (void *)result;
77507   return jresult;
77508 }
77509
77510
77511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
77512   void * jresult ;
77513   float arg1 ;
77514   float arg2 ;
77515   Dali::Toolkit::RulerDomain *result = 0 ;
77516
77517   arg1 = (float)jarg1;
77518   arg2 = (float)jarg2;
77519   {
77520     try {
77521       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
77522     } catch (std::out_of_range& e) {
77523       {
77524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77525       };
77526     } catch (std::exception& e) {
77527       {
77528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77529       };
77530     } catch (Dali::DaliException e) {
77531       {
77532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77533       };
77534     } catch (...) {
77535       {
77536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77537       };
77538     }
77539   }
77540
77541   jresult = (void *)result;
77542   return jresult;
77543 }
77544
77545
77546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
77547   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77548   float arg2 ;
77549
77550   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77551   arg2 = (float)jarg2;
77552   if (arg1) (arg1)->min = arg2;
77553 }
77554
77555
77556 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
77557   float jresult ;
77558   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77559   float result;
77560
77561   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77562   result = (float) ((arg1)->min);
77563   jresult = result;
77564   return jresult;
77565 }
77566
77567
77568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
77569   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77570   float arg2 ;
77571
77572   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77573   arg2 = (float)jarg2;
77574   if (arg1) (arg1)->max = arg2;
77575 }
77576
77577
77578 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
77579   float jresult ;
77580   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77581   float result;
77582
77583   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77584   result = (float) ((arg1)->max);
77585   jresult = result;
77586   return jresult;
77587 }
77588
77589
77590 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
77591   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77592   bool arg2 ;
77593
77594   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77595   arg2 = jarg2 ? true : false;
77596   if (arg1) (arg1)->enabled = arg2;
77597 }
77598
77599
77600 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
77601   unsigned int jresult ;
77602   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77603   bool result;
77604
77605   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77606   result = (bool) ((arg1)->enabled);
77607   jresult = result;
77608   return jresult;
77609 }
77610
77611
77612 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
77613   float jresult ;
77614   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77615   float arg2 ;
77616   float arg3 ;
77617   float arg4 ;
77618   float result;
77619
77620   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77621   arg2 = (float)jarg2;
77622   arg3 = (float)jarg3;
77623   arg4 = (float)jarg4;
77624   {
77625     try {
77626       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
77627     } catch (std::out_of_range& e) {
77628       {
77629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77630       };
77631     } catch (std::exception& e) {
77632       {
77633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77634       };
77635     } catch (Dali::DaliException e) {
77636       {
77637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77638       };
77639     } catch (...) {
77640       {
77641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77642       };
77643     }
77644   }
77645
77646   jresult = result;
77647   return jresult;
77648 }
77649
77650
77651 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
77652   float jresult ;
77653   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77654   float arg2 ;
77655   float arg3 ;
77656   float result;
77657
77658   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77659   arg2 = (float)jarg2;
77660   arg3 = (float)jarg3;
77661   {
77662     try {
77663       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
77664     } catch (std::out_of_range& e) {
77665       {
77666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77667       };
77668     } catch (std::exception& e) {
77669       {
77670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77671       };
77672     } catch (Dali::DaliException e) {
77673       {
77674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77675       };
77676     } catch (...) {
77677       {
77678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77679       };
77680     }
77681   }
77682
77683   jresult = result;
77684   return jresult;
77685 }
77686
77687
77688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
77689   float jresult ;
77690   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77691   float arg2 ;
77692   float result;
77693
77694   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77695   arg2 = (float)jarg2;
77696   {
77697     try {
77698       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
77699     } catch (std::out_of_range& e) {
77700       {
77701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77702       };
77703     } catch (std::exception& e) {
77704       {
77705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77706       };
77707     } catch (Dali::DaliException e) {
77708       {
77709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77710       };
77711     } catch (...) {
77712       {
77713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77714       };
77715     }
77716   }
77717
77718   jresult = result;
77719   return jresult;
77720 }
77721
77722
77723 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
77724   float jresult ;
77725   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77726   float arg2 ;
77727   float arg3 ;
77728   float arg4 ;
77729   Dali::Toolkit::ClampState *arg5 = 0 ;
77730   float result;
77731
77732   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77733   arg2 = (float)jarg2;
77734   arg3 = (float)jarg3;
77735   arg4 = (float)jarg4;
77736   arg5 = (Dali::Toolkit::ClampState *)jarg5;
77737   if (!arg5) {
77738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
77739     return 0;
77740   }
77741   {
77742     try {
77743       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
77744     } catch (std::out_of_range& e) {
77745       {
77746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77747       };
77748     } catch (std::exception& e) {
77749       {
77750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77751       };
77752     } catch (Dali::DaliException e) {
77753       {
77754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77755       };
77756     } catch (...) {
77757       {
77758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77759       };
77760     }
77761   }
77762
77763   jresult = result;
77764   return jresult;
77765 }
77766
77767
77768 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
77769   float jresult ;
77770   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77771   float result;
77772
77773   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77774   {
77775     try {
77776       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
77777     } catch (std::out_of_range& e) {
77778       {
77779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77780       };
77781     } catch (std::exception& e) {
77782       {
77783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77784       };
77785     } catch (Dali::DaliException e) {
77786       {
77787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77788       };
77789     } catch (...) {
77790       {
77791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77792       };
77793     }
77794   }
77795
77796   jresult = result;
77797   return jresult;
77798 }
77799
77800
77801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
77802   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
77803
77804   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
77805   {
77806     try {
77807       delete arg1;
77808     } catch (std::out_of_range& e) {
77809       {
77810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77811       };
77812     } catch (std::exception& e) {
77813       {
77814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77815       };
77816     } catch (Dali::DaliException e) {
77817       {
77818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77819       };
77820     } catch (...) {
77821       {
77822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77823       };
77824     }
77825   }
77826
77827 }
77828
77829
77830 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
77831   float jresult ;
77832   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77833   float arg2 ;
77834   float arg3 ;
77835   float result;
77836
77837   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77838   arg2 = (float)jarg2;
77839   arg3 = (float)jarg3;
77840   {
77841     try {
77842       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
77843     } catch (std::out_of_range& e) {
77844       {
77845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77846       };
77847     } catch (std::exception& e) {
77848       {
77849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77850       };
77851     } catch (Dali::DaliException e) {
77852       {
77853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77854       };
77855     } catch (...) {
77856       {
77857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77858       };
77859     }
77860   }
77861
77862   jresult = result;
77863   return jresult;
77864 }
77865
77866
77867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
77868   float jresult ;
77869   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77870   float arg2 ;
77871   float result;
77872
77873   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77874   arg2 = (float)jarg2;
77875   {
77876     try {
77877       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
77878     } catch (std::out_of_range& e) {
77879       {
77880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77881       };
77882     } catch (std::exception& e) {
77883       {
77884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77885       };
77886     } catch (Dali::DaliException e) {
77887       {
77888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77889       };
77890     } catch (...) {
77891       {
77892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77893       };
77894     }
77895   }
77896
77897   jresult = result;
77898   return jresult;
77899 }
77900
77901
77902 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
77903   float jresult ;
77904   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77905   unsigned int arg2 ;
77906   unsigned int *arg3 = 0 ;
77907   bool arg4 ;
77908   float result;
77909
77910   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77911   arg2 = (unsigned int)jarg2;
77912   arg3 = (unsigned int *)jarg3;
77913   arg4 = jarg4 ? true : false;
77914   {
77915     try {
77916       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
77917     } catch (std::out_of_range& e) {
77918       {
77919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77920       };
77921     } catch (std::exception& e) {
77922       {
77923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77924       };
77925     } catch (Dali::DaliException e) {
77926       {
77927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77928       };
77929     } catch (...) {
77930       {
77931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77932       };
77933     }
77934   }
77935
77936   jresult = result;
77937   return jresult;
77938 }
77939
77940
77941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
77942   unsigned int jresult ;
77943   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77944   float arg2 ;
77945   bool arg3 ;
77946   unsigned int result;
77947
77948   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77949   arg2 = (float)jarg2;
77950   arg3 = jarg3 ? true : false;
77951   {
77952     try {
77953       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
77954     } catch (std::out_of_range& e) {
77955       {
77956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77957       };
77958     } catch (std::exception& e) {
77959       {
77960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77961       };
77962     } catch (Dali::DaliException e) {
77963       {
77964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77965       };
77966     } catch (...) {
77967       {
77968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77969       };
77970     }
77971   }
77972
77973   jresult = result;
77974   return jresult;
77975 }
77976
77977
77978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
77979   unsigned int jresult ;
77980   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
77981   unsigned int result;
77982
77983   arg1 = (Dali::Toolkit::Ruler *)jarg1;
77984   {
77985     try {
77986       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
77987     } catch (std::out_of_range& e) {
77988       {
77989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77990       };
77991     } catch (std::exception& e) {
77992       {
77993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77994       };
77995     } catch (Dali::DaliException e) {
77996       {
77997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77998       };
77999     } catch (...) {
78000       {
78001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78002       };
78003     }
78004   }
78005
78006   jresult = result;
78007   return jresult;
78008 }
78009
78010
78011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
78012   int jresult ;
78013   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78014   Dali::Toolkit::Ruler::RulerType result;
78015
78016   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78017   {
78018     try {
78019       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
78020     } catch (std::out_of_range& e) {
78021       {
78022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78023       };
78024     } catch (std::exception& e) {
78025       {
78026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78027       };
78028     } catch (Dali::DaliException e) {
78029       {
78030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78031       };
78032     } catch (...) {
78033       {
78034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78035       };
78036     }
78037   }
78038
78039   jresult = (int)result;
78040   return jresult;
78041 }
78042
78043
78044 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
78045   unsigned int jresult ;
78046   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78047   bool result;
78048
78049   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78050   {
78051     try {
78052       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
78053     } catch (std::out_of_range& e) {
78054       {
78055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78056       };
78057     } catch (std::exception& e) {
78058       {
78059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78060       };
78061     } catch (Dali::DaliException e) {
78062       {
78063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78064       };
78065     } catch (...) {
78066       {
78067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78068       };
78069     }
78070   }
78071
78072   jresult = result;
78073   return jresult;
78074 }
78075
78076
78077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
78078   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78079
78080   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78081   {
78082     try {
78083       (arg1)->Enable();
78084     } catch (std::out_of_range& e) {
78085       {
78086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78087       };
78088     } catch (std::exception& e) {
78089       {
78090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78091       };
78092     } catch (Dali::DaliException e) {
78093       {
78094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78095       };
78096     } catch (...) {
78097       {
78098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78099       };
78100     }
78101   }
78102
78103 }
78104
78105
78106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
78107   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78108
78109   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78110   {
78111     try {
78112       (arg1)->Disable();
78113     } catch (std::out_of_range& e) {
78114       {
78115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78116       };
78117     } catch (std::exception& e) {
78118       {
78119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78120       };
78121     } catch (Dali::DaliException e) {
78122       {
78123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78124       };
78125     } catch (...) {
78126       {
78127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78128       };
78129     }
78130   }
78131
78132 }
78133
78134
78135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
78136   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78137   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
78138   Dali::Toolkit::RulerDomain *argp2 ;
78139
78140   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78141   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
78142   if (!argp2) {
78143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
78144     return ;
78145   }
78146   arg2 = *argp2;
78147   {
78148     try {
78149       (arg1)->SetDomain(arg2);
78150     } catch (std::out_of_range& e) {
78151       {
78152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78153       };
78154     } catch (std::exception& e) {
78155       {
78156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78157       };
78158     } catch (Dali::DaliException e) {
78159       {
78160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78161       };
78162     } catch (...) {
78163       {
78164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78165       };
78166     }
78167   }
78168
78169 }
78170
78171
78172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
78173   void * jresult ;
78174   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78175   Dali::Toolkit::RulerDomain *result = 0 ;
78176
78177   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78178   {
78179     try {
78180       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
78181     } catch (std::out_of_range& e) {
78182       {
78183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78184       };
78185     } catch (std::exception& e) {
78186       {
78187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78188       };
78189     } catch (Dali::DaliException e) {
78190       {
78191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78192       };
78193     } catch (...) {
78194       {
78195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78196       };
78197     }
78198   }
78199
78200   jresult = (void *)result;
78201   return jresult;
78202 }
78203
78204
78205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
78206   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78207
78208   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78209   {
78210     try {
78211       (arg1)->DisableDomain();
78212     } catch (std::out_of_range& e) {
78213       {
78214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78215       };
78216     } catch (std::exception& e) {
78217       {
78218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78219       };
78220     } catch (Dali::DaliException e) {
78221       {
78222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78223       };
78224     } catch (...) {
78225       {
78226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78227       };
78228     }
78229   }
78230
78231 }
78232
78233
78234 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
78235   float jresult ;
78236   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78237   float arg2 ;
78238   float arg3 ;
78239   float arg4 ;
78240   float result;
78241
78242   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78243   arg2 = (float)jarg2;
78244   arg3 = (float)jarg3;
78245   arg4 = (float)jarg4;
78246   {
78247     try {
78248       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
78249     } catch (std::out_of_range& e) {
78250       {
78251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78252       };
78253     } catch (std::exception& e) {
78254       {
78255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78256       };
78257     } catch (Dali::DaliException e) {
78258       {
78259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78260       };
78261     } catch (...) {
78262       {
78263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78264       };
78265     }
78266   }
78267
78268   jresult = result;
78269   return jresult;
78270 }
78271
78272
78273 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
78274   float jresult ;
78275   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78276   float arg2 ;
78277   float arg3 ;
78278   float result;
78279
78280   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78281   arg2 = (float)jarg2;
78282   arg3 = (float)jarg3;
78283   {
78284     try {
78285       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
78286     } catch (std::out_of_range& e) {
78287       {
78288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78289       };
78290     } catch (std::exception& e) {
78291       {
78292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78293       };
78294     } catch (Dali::DaliException e) {
78295       {
78296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78297       };
78298     } catch (...) {
78299       {
78300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78301       };
78302     }
78303   }
78304
78305   jresult = result;
78306   return jresult;
78307 }
78308
78309
78310 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
78311   float jresult ;
78312   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78313   float arg2 ;
78314   float result;
78315
78316   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78317   arg2 = (float)jarg2;
78318   {
78319     try {
78320       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
78321     } catch (std::out_of_range& e) {
78322       {
78323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78324       };
78325     } catch (std::exception& e) {
78326       {
78327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78328       };
78329     } catch (Dali::DaliException e) {
78330       {
78331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78332       };
78333     } catch (...) {
78334       {
78335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78336       };
78337     }
78338   }
78339
78340   jresult = result;
78341   return jresult;
78342 }
78343
78344
78345 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
78346   float jresult ;
78347   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78348   float arg2 ;
78349   float arg3 ;
78350   float arg4 ;
78351   Dali::Toolkit::ClampState *arg5 = 0 ;
78352   float result;
78353
78354   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78355   arg2 = (float)jarg2;
78356   arg3 = (float)jarg3;
78357   arg4 = (float)jarg4;
78358   arg5 = (Dali::Toolkit::ClampState *)jarg5;
78359   if (!arg5) {
78360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78361     return 0;
78362   }
78363   {
78364     try {
78365       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
78366     } catch (std::out_of_range& e) {
78367       {
78368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78369       };
78370     } catch (std::exception& e) {
78371       {
78372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78373       };
78374     } catch (Dali::DaliException e) {
78375       {
78376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78377       };
78378     } catch (...) {
78379       {
78380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78381       };
78382     }
78383   }
78384
78385   jresult = result;
78386   return jresult;
78387 }
78388
78389
78390 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
78391   float jresult ;
78392   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78393   float arg2 ;
78394   float arg3 ;
78395   float arg4 ;
78396   float arg5 ;
78397   float result;
78398
78399   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78400   arg2 = (float)jarg2;
78401   arg3 = (float)jarg3;
78402   arg4 = (float)jarg4;
78403   arg5 = (float)jarg5;
78404   {
78405     try {
78406       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
78407     } catch (std::out_of_range& e) {
78408       {
78409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78410       };
78411     } catch (std::exception& e) {
78412       {
78413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78414       };
78415     } catch (Dali::DaliException e) {
78416       {
78417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78418       };
78419     } catch (...) {
78420       {
78421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78422       };
78423     }
78424   }
78425
78426   jresult = result;
78427   return jresult;
78428 }
78429
78430
78431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
78432   float jresult ;
78433   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78434   float arg2 ;
78435   float arg3 ;
78436   float arg4 ;
78437   float result;
78438
78439   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78440   arg2 = (float)jarg2;
78441   arg3 = (float)jarg3;
78442   arg4 = (float)jarg4;
78443   {
78444     try {
78445       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
78446     } catch (std::out_of_range& e) {
78447       {
78448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78449       };
78450     } catch (std::exception& e) {
78451       {
78452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78453       };
78454     } catch (Dali::DaliException e) {
78455       {
78456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78457       };
78458     } catch (...) {
78459       {
78460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78461       };
78462     }
78463   }
78464
78465   jresult = result;
78466   return jresult;
78467 }
78468
78469
78470 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
78471   float jresult ;
78472   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78473   float arg2 ;
78474   float arg3 ;
78475   float result;
78476
78477   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78478   arg2 = (float)jarg2;
78479   arg3 = (float)jarg3;
78480   {
78481     try {
78482       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
78483     } catch (std::out_of_range& e) {
78484       {
78485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78486       };
78487     } catch (std::exception& e) {
78488       {
78489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78490       };
78491     } catch (Dali::DaliException e) {
78492       {
78493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78494       };
78495     } catch (...) {
78496       {
78497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78498       };
78499     }
78500   }
78501
78502   jresult = result;
78503   return jresult;
78504 }
78505
78506
78507 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
78508   float jresult ;
78509   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78510   float arg2 ;
78511   float result;
78512
78513   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78514   arg2 = (float)jarg2;
78515   {
78516     try {
78517       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
78518     } catch (std::out_of_range& e) {
78519       {
78520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78521       };
78522     } catch (std::exception& e) {
78523       {
78524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78525       };
78526     } catch (Dali::DaliException e) {
78527       {
78528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78529       };
78530     } catch (...) {
78531       {
78532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78533       };
78534     }
78535   }
78536
78537   jresult = result;
78538   return jresult;
78539 }
78540
78541
78542 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
78543   float jresult ;
78544   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
78545   float arg2 ;
78546   float arg3 ;
78547   float arg4 ;
78548   float arg5 ;
78549   Dali::Toolkit::ClampState *arg6 = 0 ;
78550   float result;
78551
78552   arg1 = (Dali::Toolkit::Ruler *)jarg1;
78553   arg2 = (float)jarg2;
78554   arg3 = (float)jarg3;
78555   arg4 = (float)jarg4;
78556   arg5 = (float)jarg5;
78557   arg6 = (Dali::Toolkit::ClampState *)jarg6;
78558   if (!arg6) {
78559     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
78560     return 0;
78561   }
78562   {
78563     try {
78564       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
78565     } catch (std::out_of_range& e) {
78566       {
78567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78568       };
78569     } catch (std::exception& e) {
78570       {
78571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78572       };
78573     } catch (Dali::DaliException e) {
78574       {
78575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78576       };
78577     } catch (...) {
78578       {
78579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78580       };
78581     }
78582   }
78583
78584   jresult = result;
78585   return jresult;
78586 }
78587
78588
78589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
78590   void * jresult ;
78591   Dali::Toolkit::DefaultRuler *result = 0 ;
78592
78593   {
78594     try {
78595       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
78596     } catch (std::out_of_range& e) {
78597       {
78598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78599       };
78600     } catch (std::exception& e) {
78601       {
78602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78603       };
78604     } catch (Dali::DaliException e) {
78605       {
78606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78607       };
78608     } catch (...) {
78609       {
78610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78611       };
78612     }
78613   }
78614
78615   jresult = (void *)result;
78616   return jresult;
78617 }
78618
78619
78620 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78621   float jresult ;
78622   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78623   float arg2 ;
78624   float arg3 ;
78625   float result;
78626
78627   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78628   arg2 = (float)jarg2;
78629   arg3 = (float)jarg3;
78630   {
78631     try {
78632       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
78633     } catch (std::out_of_range& e) {
78634       {
78635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78636       };
78637     } catch (std::exception& e) {
78638       {
78639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78640       };
78641     } catch (Dali::DaliException e) {
78642       {
78643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78644       };
78645     } catch (...) {
78646       {
78647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78648       };
78649     }
78650   }
78651
78652   jresult = result;
78653   return jresult;
78654 }
78655
78656
78657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78658   float jresult ;
78659   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78660   unsigned int arg2 ;
78661   unsigned int *arg3 = 0 ;
78662   bool arg4 ;
78663   float result;
78664
78665   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78666   arg2 = (unsigned int)jarg2;
78667   arg3 = (unsigned int *)jarg3;
78668   arg4 = jarg4 ? true : false;
78669   {
78670     try {
78671       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78672     } catch (std::out_of_range& e) {
78673       {
78674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78675       };
78676     } catch (std::exception& e) {
78677       {
78678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78679       };
78680     } catch (Dali::DaliException e) {
78681       {
78682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78683       };
78684     } catch (...) {
78685       {
78686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78687       };
78688     }
78689   }
78690
78691   jresult = result;
78692   return jresult;
78693 }
78694
78695
78696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78697   unsigned int jresult ;
78698   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78699   float arg2 ;
78700   bool arg3 ;
78701   unsigned int result;
78702
78703   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78704   arg2 = (float)jarg2;
78705   arg3 = jarg3 ? true : false;
78706   {
78707     try {
78708       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78709     } catch (std::out_of_range& e) {
78710       {
78711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78712       };
78713     } catch (std::exception& e) {
78714       {
78715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78716       };
78717     } catch (Dali::DaliException e) {
78718       {
78719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78720       };
78721     } catch (...) {
78722       {
78723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78724       };
78725     }
78726   }
78727
78728   jresult = result;
78729   return jresult;
78730 }
78731
78732
78733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
78734   unsigned int jresult ;
78735   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78736   unsigned int result;
78737
78738   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78739   {
78740     try {
78741       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
78742     } catch (std::out_of_range& e) {
78743       {
78744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78745       };
78746     } catch (std::exception& e) {
78747       {
78748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78749       };
78750     } catch (Dali::DaliException e) {
78751       {
78752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78753       };
78754     } catch (...) {
78755       {
78756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78757       };
78758     }
78759   }
78760
78761   jresult = result;
78762   return jresult;
78763 }
78764
78765
78766 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
78767   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
78768
78769   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
78770   {
78771     try {
78772       delete arg1;
78773     } catch (std::out_of_range& e) {
78774       {
78775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78776       };
78777     } catch (std::exception& e) {
78778       {
78779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78780       };
78781     } catch (Dali::DaliException e) {
78782       {
78783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78784       };
78785     } catch (...) {
78786       {
78787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78788       };
78789     }
78790   }
78791
78792 }
78793
78794
78795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
78796   void * jresult ;
78797   float arg1 ;
78798   Dali::Toolkit::FixedRuler *result = 0 ;
78799
78800   arg1 = (float)jarg1;
78801   {
78802     try {
78803       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
78804     } catch (std::out_of_range& e) {
78805       {
78806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78807       };
78808     } catch (std::exception& e) {
78809       {
78810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78811       };
78812     } catch (Dali::DaliException e) {
78813       {
78814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78815       };
78816     } catch (...) {
78817       {
78818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78819       };
78820     }
78821   }
78822
78823   jresult = (void *)result;
78824   return jresult;
78825 }
78826
78827
78828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
78829   void * jresult ;
78830   Dali::Toolkit::FixedRuler *result = 0 ;
78831
78832   {
78833     try {
78834       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
78835     } catch (std::out_of_range& e) {
78836       {
78837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78838       };
78839     } catch (std::exception& e) {
78840       {
78841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78842       };
78843     } catch (Dali::DaliException e) {
78844       {
78845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78846       };
78847     } catch (...) {
78848       {
78849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78850       };
78851     }
78852   }
78853
78854   jresult = (void *)result;
78855   return jresult;
78856 }
78857
78858
78859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
78860   float jresult ;
78861   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78862   float arg2 ;
78863   float arg3 ;
78864   float result;
78865
78866   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78867   arg2 = (float)jarg2;
78868   arg3 = (float)jarg3;
78869   {
78870     try {
78871       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
78872     } catch (std::out_of_range& e) {
78873       {
78874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78875       };
78876     } catch (std::exception& e) {
78877       {
78878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78879       };
78880     } catch (Dali::DaliException e) {
78881       {
78882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78883       };
78884     } catch (...) {
78885       {
78886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78887       };
78888     }
78889   }
78890
78891   jresult = result;
78892   return jresult;
78893 }
78894
78895
78896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
78897   float jresult ;
78898   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78899   unsigned int arg2 ;
78900   unsigned int *arg3 = 0 ;
78901   bool arg4 ;
78902   float result;
78903
78904   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78905   arg2 = (unsigned int)jarg2;
78906   arg3 = (unsigned int *)jarg3;
78907   arg4 = jarg4 ? true : false;
78908   {
78909     try {
78910       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
78911     } catch (std::out_of_range& e) {
78912       {
78913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78914       };
78915     } catch (std::exception& e) {
78916       {
78917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78918       };
78919     } catch (Dali::DaliException e) {
78920       {
78921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78922       };
78923     } catch (...) {
78924       {
78925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78926       };
78927     }
78928   }
78929
78930   jresult = result;
78931   return jresult;
78932 }
78933
78934
78935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
78936   unsigned int jresult ;
78937   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78938   float arg2 ;
78939   bool arg3 ;
78940   unsigned int result;
78941
78942   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78943   arg2 = (float)jarg2;
78944   arg3 = jarg3 ? true : false;
78945   {
78946     try {
78947       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
78948     } catch (std::out_of_range& e) {
78949       {
78950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78951       };
78952     } catch (std::exception& e) {
78953       {
78954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78955       };
78956     } catch (Dali::DaliException e) {
78957       {
78958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78959       };
78960     } catch (...) {
78961       {
78962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78963       };
78964     }
78965   }
78966
78967   jresult = result;
78968   return jresult;
78969 }
78970
78971
78972 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
78973   unsigned int jresult ;
78974   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
78975   unsigned int result;
78976
78977   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
78978   {
78979     try {
78980       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
78981     } catch (std::out_of_range& e) {
78982       {
78983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78984       };
78985     } catch (std::exception& e) {
78986       {
78987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78988       };
78989     } catch (Dali::DaliException e) {
78990       {
78991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78992       };
78993     } catch (...) {
78994       {
78995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78996       };
78997     }
78998   }
78999
79000   jresult = result;
79001   return jresult;
79002 }
79003
79004
79005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
79006   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
79007
79008   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
79009   {
79010     try {
79011       delete arg1;
79012     } catch (std::out_of_range& e) {
79013       {
79014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79015       };
79016     } catch (std::exception& e) {
79017       {
79018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79019       };
79020     } catch (Dali::DaliException e) {
79021       {
79022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79023       };
79024     } catch (...) {
79025       {
79026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79027       };
79028     }
79029   }
79030
79031 }
79032
79033
79034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
79035   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79036   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79037
79038   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79039   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79040   if (arg1) (arg1)->scale = *arg2;
79041 }
79042
79043
79044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
79045   void * jresult ;
79046   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79047   Dali::Toolkit::ClampState2D *result = 0 ;
79048
79049   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79050   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
79051   jresult = (void *)result;
79052   return jresult;
79053 }
79054
79055
79056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
79057   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79058   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
79059
79060   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79061   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
79062   if (arg1) (arg1)->position = *arg2;
79063 }
79064
79065
79066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
79067   void * jresult ;
79068   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79069   Dali::Toolkit::ClampState2D *result = 0 ;
79070
79071   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79072   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
79073   jresult = (void *)result;
79074   return jresult;
79075 }
79076
79077
79078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
79079   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79080   Dali::Toolkit::ClampState arg2 ;
79081
79082   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79083   arg2 = (Dali::Toolkit::ClampState)jarg2;
79084   if (arg1) (arg1)->rotation = arg2;
79085 }
79086
79087
79088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
79089   int jresult ;
79090   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79091   Dali::Toolkit::ClampState result;
79092
79093   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79094   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
79095   jresult = (int)result;
79096   return jresult;
79097 }
79098
79099
79100 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
79101   void * jresult ;
79102   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
79103
79104   {
79105     try {
79106       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
79107     } catch (std::out_of_range& e) {
79108       {
79109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79110       };
79111     } catch (std::exception& e) {
79112       {
79113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79114       };
79115     } catch (Dali::DaliException e) {
79116       {
79117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79118       };
79119     } catch (...) {
79120       {
79121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79122       };
79123     }
79124   }
79125
79126   jresult = (void *)result;
79127   return jresult;
79128 }
79129
79130
79131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
79132   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
79133
79134   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
79135   {
79136     try {
79137       delete arg1;
79138     } catch (std::out_of_range& e) {
79139       {
79140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79141       };
79142     } catch (std::exception& e) {
79143       {
79144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79145       };
79146     } catch (Dali::DaliException e) {
79147       {
79148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79149       };
79150     } catch (...) {
79151       {
79152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79153       };
79154     }
79155   }
79156
79157 }
79158
79159
79160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
79161   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79162   Dali::Toolkit::SnapType arg2 ;
79163
79164   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79165   arg2 = (Dali::Toolkit::SnapType)jarg2;
79166   if (arg1) (arg1)->type = arg2;
79167 }
79168
79169
79170 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
79171   int jresult ;
79172   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79173   Dali::Toolkit::SnapType result;
79174
79175   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79176   result = (Dali::Toolkit::SnapType) ((arg1)->type);
79177   jresult = (int)result;
79178   return jresult;
79179 }
79180
79181
79182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
79183   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79184   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
79185
79186   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79187   arg2 = (Dali::Vector2 *)jarg2;
79188   if (arg1) (arg1)->position = *arg2;
79189 }
79190
79191
79192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
79193   void * jresult ;
79194   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79195   Dali::Vector2 *result = 0 ;
79196
79197   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79198   result = (Dali::Vector2 *)& ((arg1)->position);
79199   jresult = (void *)result;
79200   return jresult;
79201 }
79202
79203
79204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
79205   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79206   float arg2 ;
79207
79208   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79209   arg2 = (float)jarg2;
79210   if (arg1) (arg1)->duration = arg2;
79211 }
79212
79213
79214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
79215   float jresult ;
79216   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79217   float result;
79218
79219   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79220   result = (float) ((arg1)->duration);
79221   jresult = result;
79222   return jresult;
79223 }
79224
79225
79226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
79227   void * jresult ;
79228   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
79229
79230   {
79231     try {
79232       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
79233     } catch (std::out_of_range& e) {
79234       {
79235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79236       };
79237     } catch (std::exception& e) {
79238       {
79239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79240       };
79241     } catch (Dali::DaliException e) {
79242       {
79243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79244       };
79245     } catch (...) {
79246       {
79247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79248       };
79249     }
79250   }
79251
79252   jresult = (void *)result;
79253   return jresult;
79254 }
79255
79256
79257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
79258   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
79259
79260   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
79261   {
79262     try {
79263       delete arg1;
79264     } catch (std::out_of_range& e) {
79265       {
79266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79267       };
79268     } catch (std::exception& e) {
79269       {
79270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79271       };
79272     } catch (Dali::DaliException e) {
79273       {
79274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79275       };
79276     } catch (...) {
79277       {
79278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79279       };
79280     }
79281   }
79282
79283 }
79284
79285
79286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
79287   int jresult ;
79288   int result;
79289
79290   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
79291   jresult = (int)result;
79292   return jresult;
79293 }
79294
79295
79296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
79297   int jresult ;
79298   int result;
79299
79300   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
79301   jresult = (int)result;
79302   return jresult;
79303 }
79304
79305
79306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
79307   int jresult ;
79308   int result;
79309
79310   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
79311   jresult = (int)result;
79312   return jresult;
79313 }
79314
79315
79316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
79317   int jresult ;
79318   int result;
79319
79320   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
79321   jresult = (int)result;
79322   return jresult;
79323 }
79324
79325
79326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
79327   int jresult ;
79328   int result;
79329
79330   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
79331   jresult = (int)result;
79332   return jresult;
79333 }
79334
79335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
79336   int jresult ;
79337   int result;
79338
79339   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
79340   jresult = (int)result;
79341   return jresult;
79342 }
79343
79344
79345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
79346   int jresult ;
79347   int result;
79348
79349   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
79350   jresult = (int)result;
79351   return jresult;
79352 }
79353
79354
79355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
79356   int jresult ;
79357   int result;
79358
79359   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
79360   jresult = (int)result;
79361   return jresult;
79362 }
79363
79364
79365 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
79366   int jresult ;
79367   int result;
79368
79369   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
79370   jresult = (int)result;
79371   return jresult;
79372 }
79373
79374
79375 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
79376   int jresult ;
79377   int result;
79378
79379   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
79380   jresult = (int)result;
79381   return jresult;
79382 }
79383
79384
79385 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
79386   int jresult ;
79387   int result;
79388
79389   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
79390   jresult = (int)result;
79391   return jresult;
79392 }
79393
79394
79395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
79396   int jresult ;
79397   int result;
79398
79399   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
79400   jresult = (int)result;
79401   return jresult;
79402 }
79403
79404
79405 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
79406   int jresult ;
79407   int result;
79408
79409   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
79410   jresult = (int)result;
79411   return jresult;
79412 }
79413
79414
79415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
79416   int jresult ;
79417   int result;
79418
79419   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
79420   jresult = (int)result;
79421   return jresult;
79422 }
79423
79424
79425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
79426   int jresult ;
79427   int result;
79428
79429   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
79430   jresult = (int)result;
79431   return jresult;
79432 }
79433
79434
79435 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
79436   int jresult ;
79437   int result;
79438
79439   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
79440   jresult = (int)result;
79441   return jresult;
79442 }
79443
79444
79445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
79446   int jresult ;
79447   int result;
79448
79449   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
79450   jresult = (int)result;
79451   return jresult;
79452 }
79453
79454
79455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
79456   int jresult ;
79457   int result;
79458
79459   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
79460   jresult = (int)result;
79461   return jresult;
79462 }
79463
79464
79465 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
79466   int jresult ;
79467   int result;
79468
79469   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
79470   jresult = (int)result;
79471   return jresult;
79472 }
79473
79474
79475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
79476   int jresult ;
79477   int result;
79478
79479   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
79480   jresult = (int)result;
79481   return jresult;
79482 }
79483
79484
79485 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
79486   int jresult ;
79487   int result;
79488
79489   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
79490   jresult = (int)result;
79491   return jresult;
79492 }
79493
79494
79495 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
79496   int jresult ;
79497   int result;
79498
79499   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
79500   jresult = (int)result;
79501   return jresult;
79502 }
79503
79504
79505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
79506   int jresult ;
79507   int result;
79508
79509   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
79510   jresult = (int)result;
79511   return jresult;
79512 }
79513
79514
79515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
79516   int jresult ;
79517   int result;
79518
79519   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
79520   jresult = (int)result;
79521   return jresult;
79522 }
79523
79524
79525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
79526   int jresult ;
79527   int result;
79528
79529   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
79530   jresult = (int)result;
79531   return jresult;
79532 }
79533
79534
79535 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
79536   int jresult ;
79537   int result;
79538
79539   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
79540   jresult = (int)result;
79541   return jresult;
79542 }
79543
79544
79545 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
79546   void * jresult ;
79547   Dali::Toolkit::ScrollView::Property *result = 0 ;
79548
79549   {
79550     try {
79551       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
79552     } catch (std::out_of_range& e) {
79553       {
79554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79555       };
79556     } catch (std::exception& e) {
79557       {
79558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79559       };
79560     } catch (Dali::DaliException e) {
79561       {
79562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79563       };
79564     } catch (...) {
79565       {
79566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79567       };
79568     }
79569   }
79570
79571   jresult = (void *)result;
79572   return jresult;
79573 }
79574
79575
79576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
79577   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
79578
79579   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
79580   {
79581     try {
79582       delete arg1;
79583     } catch (std::out_of_range& e) {
79584       {
79585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79586       };
79587     } catch (std::exception& e) {
79588       {
79589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79590       };
79591     } catch (Dali::DaliException e) {
79592       {
79593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79594       };
79595     } catch (...) {
79596       {
79597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79598       };
79599     }
79600   }
79601
79602 }
79603
79604
79605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
79606   void * jresult ;
79607   Dali::Toolkit::ScrollView *result = 0 ;
79608
79609   {
79610     try {
79611       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
79612     } catch (std::out_of_range& e) {
79613       {
79614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79615       };
79616     } catch (std::exception& e) {
79617       {
79618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79619       };
79620     } catch (Dali::DaliException e) {
79621       {
79622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79623       };
79624     } catch (...) {
79625       {
79626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79627       };
79628     }
79629   }
79630
79631   jresult = (void *)result;
79632   return jresult;
79633 }
79634
79635
79636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
79637   void * jresult ;
79638   Dali::Toolkit::ScrollView *arg1 = 0 ;
79639   Dali::Toolkit::ScrollView *result = 0 ;
79640
79641   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79642   if (!arg1) {
79643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79644     return 0;
79645   }
79646   {
79647     try {
79648       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
79649     } catch (std::out_of_range& e) {
79650       {
79651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79652       };
79653     } catch (std::exception& e) {
79654       {
79655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79656       };
79657     } catch (Dali::DaliException e) {
79658       {
79659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79660       };
79661     } catch (...) {
79662       {
79663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79664       };
79665     }
79666   }
79667
79668   jresult = (void *)result;
79669   return jresult;
79670 }
79671
79672
79673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
79674   void * jresult ;
79675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79676   Dali::Toolkit::ScrollView *arg2 = 0 ;
79677   Dali::Toolkit::ScrollView *result = 0 ;
79678
79679   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79680   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
79681   if (!arg2) {
79682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
79683     return 0;
79684   }
79685   {
79686     try {
79687       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
79688     } catch (std::out_of_range& e) {
79689       {
79690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79691       };
79692     } catch (std::exception& e) {
79693       {
79694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79695       };
79696     } catch (Dali::DaliException e) {
79697       {
79698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79699       };
79700     } catch (...) {
79701       {
79702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79703       };
79704     }
79705   }
79706
79707   jresult = (void *)result;
79708   return jresult;
79709 }
79710
79711
79712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
79713   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79714
79715   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79716   {
79717     try {
79718       delete arg1;
79719     } catch (std::out_of_range& e) {
79720       {
79721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79722       };
79723     } catch (std::exception& e) {
79724       {
79725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79726       };
79727     } catch (Dali::DaliException e) {
79728       {
79729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79730       };
79731     } catch (...) {
79732       {
79733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79734       };
79735     }
79736   }
79737
79738 }
79739
79740
79741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
79742   void * jresult ;
79743   Dali::Toolkit::ScrollView result;
79744
79745   {
79746     try {
79747       result = Dali::Toolkit::ScrollView::New();
79748     } catch (std::out_of_range& e) {
79749       {
79750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79751       };
79752     } catch (std::exception& e) {
79753       {
79754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79755       };
79756     } catch (Dali::DaliException e) {
79757       {
79758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79759       };
79760     } catch (...) {
79761       {
79762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79763       };
79764     }
79765   }
79766
79767   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79768   return jresult;
79769 }
79770
79771
79772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
79773   void * jresult ;
79774   Dali::BaseHandle arg1 ;
79775   Dali::BaseHandle *argp1 ;
79776   Dali::Toolkit::ScrollView result;
79777
79778   argp1 = (Dali::BaseHandle *)jarg1;
79779   if (!argp1) {
79780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79781     return 0;
79782   }
79783   arg1 = *argp1;
79784   {
79785     try {
79786       result = Dali::Toolkit::ScrollView::DownCast(arg1);
79787     } catch (std::out_of_range& e) {
79788       {
79789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79790       };
79791     } catch (std::exception& e) {
79792       {
79793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79794       };
79795     } catch (Dali::DaliException e) {
79796       {
79797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79798       };
79799     } catch (...) {
79800       {
79801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79802       };
79803     }
79804   }
79805
79806   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
79807   return jresult;
79808 }
79809
79810
79811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
79812   void * jresult ;
79813   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79814   Dali::AlphaFunction result;
79815
79816   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79817   {
79818     try {
79819       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
79820     } catch (std::out_of_range& e) {
79821       {
79822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79823       };
79824     } catch (std::exception& e) {
79825       {
79826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79827       };
79828     } catch (Dali::DaliException e) {
79829       {
79830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79831       };
79832     } catch (...) {
79833       {
79834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79835       };
79836     }
79837   }
79838
79839   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79840   return jresult;
79841 }
79842
79843
79844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
79845   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79846   Dali::AlphaFunction arg2 ;
79847   Dali::AlphaFunction *argp2 ;
79848
79849   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79850   argp2 = (Dali::AlphaFunction *)jarg2;
79851   if (!argp2) {
79852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79853     return ;
79854   }
79855   arg2 = *argp2;
79856   {
79857     try {
79858       (arg1)->SetScrollSnapAlphaFunction(arg2);
79859     } catch (std::out_of_range& e) {
79860       {
79861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79862       };
79863     } catch (std::exception& e) {
79864       {
79865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79866       };
79867     } catch (Dali::DaliException e) {
79868       {
79869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79870       };
79871     } catch (...) {
79872       {
79873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79874       };
79875     }
79876   }
79877
79878 }
79879
79880
79881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
79882   void * jresult ;
79883   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79884   Dali::AlphaFunction result;
79885
79886   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79887   {
79888     try {
79889       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
79890     } catch (std::out_of_range& e) {
79891       {
79892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79893       };
79894     } catch (std::exception& e) {
79895       {
79896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79897       };
79898     } catch (Dali::DaliException e) {
79899       {
79900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79901       };
79902     } catch (...) {
79903       {
79904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79905       };
79906     }
79907   }
79908
79909   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
79910   return jresult;
79911 }
79912
79913
79914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
79915   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79916   Dali::AlphaFunction arg2 ;
79917   Dali::AlphaFunction *argp2 ;
79918
79919   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79920   argp2 = (Dali::AlphaFunction *)jarg2;
79921   if (!argp2) {
79922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79923     return ;
79924   }
79925   arg2 = *argp2;
79926   {
79927     try {
79928       (arg1)->SetScrollFlickAlphaFunction(arg2);
79929     } catch (std::out_of_range& e) {
79930       {
79931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79932       };
79933     } catch (std::exception& e) {
79934       {
79935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79936       };
79937     } catch (Dali::DaliException e) {
79938       {
79939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79940       };
79941     } catch (...) {
79942       {
79943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79944       };
79945     }
79946   }
79947
79948 }
79949
79950
79951 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
79952   float jresult ;
79953   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79954   float result;
79955
79956   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79957   {
79958     try {
79959       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
79960     } catch (std::out_of_range& e) {
79961       {
79962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79963       };
79964     } catch (std::exception& e) {
79965       {
79966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79967       };
79968     } catch (Dali::DaliException e) {
79969       {
79970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79971       };
79972     } catch (...) {
79973       {
79974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79975       };
79976     }
79977   }
79978
79979   jresult = result;
79980   return jresult;
79981 }
79982
79983
79984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
79985   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79986   float arg2 ;
79987
79988   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79989   arg2 = (float)jarg2;
79990   {
79991     try {
79992       (arg1)->SetScrollSnapDuration(arg2);
79993     } catch (std::out_of_range& e) {
79994       {
79995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79996       };
79997     } catch (std::exception& e) {
79998       {
79999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80000       };
80001     } catch (Dali::DaliException e) {
80002       {
80003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80004       };
80005     } catch (...) {
80006       {
80007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80008       };
80009     }
80010   }
80011
80012 }
80013
80014
80015 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
80016   float jresult ;
80017   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80018   float result;
80019
80020   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80021   {
80022     try {
80023       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
80024     } catch (std::out_of_range& e) {
80025       {
80026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80027       };
80028     } catch (std::exception& e) {
80029       {
80030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80031       };
80032     } catch (Dali::DaliException e) {
80033       {
80034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80035       };
80036     } catch (...) {
80037       {
80038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80039       };
80040     }
80041   }
80042
80043   jresult = result;
80044   return jresult;
80045 }
80046
80047
80048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
80049   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80050   float arg2 ;
80051
80052   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80053   arg2 = (float)jarg2;
80054   {
80055     try {
80056       (arg1)->SetScrollFlickDuration(arg2);
80057     } catch (std::out_of_range& e) {
80058       {
80059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80060       };
80061     } catch (std::exception& e) {
80062       {
80063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80064       };
80065     } catch (Dali::DaliException e) {
80066       {
80067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80068       };
80069     } catch (...) {
80070       {
80071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80072       };
80073     }
80074   }
80075
80076 }
80077
80078
80079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
80080   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80081   Dali::Toolkit::RulerPtr arg2 ;
80082   Dali::Toolkit::RulerPtr *argp2 ;
80083
80084   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80085   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80086   if (!argp2) {
80087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80088     return ;
80089   }
80090   arg2 = *argp2;
80091   {
80092     try {
80093       (arg1)->SetRulerX(arg2);
80094     } catch (std::out_of_range& e) {
80095       {
80096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80097       };
80098     } catch (std::exception& e) {
80099       {
80100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80101       };
80102     } catch (Dali::DaliException e) {
80103       {
80104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80105       };
80106     } catch (...) {
80107       {
80108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80109       };
80110     }
80111   }
80112
80113 }
80114
80115
80116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
80117   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80118   Dali::Toolkit::RulerPtr arg2 ;
80119   Dali::Toolkit::RulerPtr *argp2 ;
80120
80121   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80122   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
80123   if (!argp2) {
80124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
80125     return ;
80126   }
80127   arg2 = *argp2;
80128   {
80129     try {
80130       (arg1)->SetRulerY(arg2);
80131     } catch (std::out_of_range& e) {
80132       {
80133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80134       };
80135     } catch (std::exception& e) {
80136       {
80137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80138       };
80139     } catch (Dali::DaliException e) {
80140       {
80141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80142       };
80143     } catch (...) {
80144       {
80145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80146       };
80147     }
80148   }
80149
80150 }
80151
80152
80153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
80154   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80155   bool arg2 ;
80156
80157   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80158   arg2 = jarg2 ? true : false;
80159   {
80160     try {
80161       (arg1)->SetScrollSensitive(arg2);
80162     } catch (std::out_of_range& e) {
80163       {
80164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80165       };
80166     } catch (std::exception& e) {
80167       {
80168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80169       };
80170     } catch (Dali::DaliException e) {
80171       {
80172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80173       };
80174     } catch (...) {
80175       {
80176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80177       };
80178     }
80179   }
80180
80181 }
80182
80183
80184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
80185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80186   float arg2 ;
80187   float arg3 ;
80188
80189   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80190   arg2 = (float)jarg2;
80191   arg3 = (float)jarg3;
80192   {
80193     try {
80194       (arg1)->SetMaxOvershoot(arg2,arg3);
80195     } catch (std::out_of_range& e) {
80196       {
80197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80198       };
80199     } catch (std::exception& e) {
80200       {
80201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80202       };
80203     } catch (Dali::DaliException e) {
80204       {
80205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80206       };
80207     } catch (...) {
80208       {
80209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80210       };
80211     }
80212   }
80213
80214 }
80215
80216
80217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
80218   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80219   Dali::AlphaFunction arg2 ;
80220   Dali::AlphaFunction *argp2 ;
80221
80222   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80223   argp2 = (Dali::AlphaFunction *)jarg2;
80224   if (!argp2) {
80225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
80226     return ;
80227   }
80228   arg2 = *argp2;
80229   {
80230     try {
80231       (arg1)->SetSnapOvershootAlphaFunction(arg2);
80232     } catch (std::out_of_range& e) {
80233       {
80234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80235       };
80236     } catch (std::exception& e) {
80237       {
80238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80239       };
80240     } catch (Dali::DaliException e) {
80241       {
80242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80243       };
80244     } catch (...) {
80245       {
80246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80247       };
80248     }
80249   }
80250
80251 }
80252
80253
80254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
80255   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80256   float arg2 ;
80257
80258   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80259   arg2 = (float)jarg2;
80260   {
80261     try {
80262       (arg1)->SetSnapOvershootDuration(arg2);
80263     } catch (std::out_of_range& e) {
80264       {
80265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80266       };
80267     } catch (std::exception& e) {
80268       {
80269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80270       };
80271     } catch (Dali::DaliException e) {
80272       {
80273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80274       };
80275     } catch (...) {
80276       {
80277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80278       };
80279     }
80280   }
80281
80282 }
80283
80284
80285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
80286   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80287   bool arg2 ;
80288
80289   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80290   arg2 = jarg2 ? true : false;
80291   {
80292     try {
80293       (arg1)->SetActorAutoSnap(arg2);
80294     } catch (std::out_of_range& e) {
80295       {
80296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80297       };
80298     } catch (std::exception& e) {
80299       {
80300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80301       };
80302     } catch (Dali::DaliException e) {
80303       {
80304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80305       };
80306     } catch (...) {
80307       {
80308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80309       };
80310     }
80311   }
80312
80313 }
80314
80315
80316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
80317   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80318   bool arg2 ;
80319
80320   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80321   arg2 = jarg2 ? true : false;
80322   {
80323     try {
80324       (arg1)->SetWrapMode(arg2);
80325     } catch (std::out_of_range& e) {
80326       {
80327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80328       };
80329     } catch (std::exception& e) {
80330       {
80331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80332       };
80333     } catch (Dali::DaliException e) {
80334       {
80335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80336       };
80337     } catch (...) {
80338       {
80339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80340       };
80341     }
80342   }
80343
80344 }
80345
80346
80347 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
80348   int jresult ;
80349   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80350   int result;
80351
80352   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80353   {
80354     try {
80355       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
80356     } catch (std::out_of_range& e) {
80357       {
80358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80359       };
80360     } catch (std::exception& e) {
80361       {
80362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80363       };
80364     } catch (Dali::DaliException e) {
80365       {
80366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80367       };
80368     } catch (...) {
80369       {
80370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80371       };
80372     }
80373   }
80374
80375   jresult = result;
80376   return jresult;
80377 }
80378
80379
80380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
80381   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80382   int arg2 ;
80383
80384   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80385   arg2 = (int)jarg2;
80386   {
80387     try {
80388       (arg1)->SetScrollUpdateDistance(arg2);
80389     } catch (std::out_of_range& e) {
80390       {
80391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80392       };
80393     } catch (std::exception& e) {
80394       {
80395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80396       };
80397     } catch (Dali::DaliException e) {
80398       {
80399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80400       };
80401     } catch (...) {
80402       {
80403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80404       };
80405     }
80406   }
80407
80408 }
80409
80410
80411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
80412   unsigned int jresult ;
80413   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80414   bool result;
80415
80416   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80417   {
80418     try {
80419       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
80420     } catch (std::out_of_range& e) {
80421       {
80422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80423       };
80424     } catch (std::exception& e) {
80425       {
80426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80427       };
80428     } catch (Dali::DaliException e) {
80429       {
80430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80431       };
80432     } catch (...) {
80433       {
80434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80435       };
80436     }
80437   }
80438
80439   jresult = result;
80440   return jresult;
80441 }
80442
80443
80444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
80445   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80446   bool arg2 ;
80447
80448   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80449   arg2 = jarg2 ? true : false;
80450   {
80451     try {
80452       (arg1)->SetAxisAutoLock(arg2);
80453     } catch (std::out_of_range& e) {
80454       {
80455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80456       };
80457     } catch (std::exception& e) {
80458       {
80459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80460       };
80461     } catch (Dali::DaliException e) {
80462       {
80463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80464       };
80465     } catch (...) {
80466       {
80467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80468       };
80469     }
80470   }
80471
80472 }
80473
80474
80475 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
80476   float jresult ;
80477   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80478   float result;
80479
80480   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80481   {
80482     try {
80483       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
80484     } catch (std::out_of_range& e) {
80485       {
80486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80487       };
80488     } catch (std::exception& e) {
80489       {
80490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80491       };
80492     } catch (Dali::DaliException e) {
80493       {
80494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80495       };
80496     } catch (...) {
80497       {
80498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80499       };
80500     }
80501   }
80502
80503   jresult = result;
80504   return jresult;
80505 }
80506
80507
80508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
80509   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80510   float arg2 ;
80511
80512   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80513   arg2 = (float)jarg2;
80514   {
80515     try {
80516       (arg1)->SetAxisAutoLockGradient(arg2);
80517     } catch (std::out_of_range& e) {
80518       {
80519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80520       };
80521     } catch (std::exception& e) {
80522       {
80523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80524       };
80525     } catch (Dali::DaliException e) {
80526       {
80527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80528       };
80529     } catch (...) {
80530       {
80531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80532       };
80533     }
80534   }
80535
80536 }
80537
80538
80539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
80540   float jresult ;
80541   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80542   float result;
80543
80544   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80545   {
80546     try {
80547       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
80548     } catch (std::out_of_range& e) {
80549       {
80550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80551       };
80552     } catch (std::exception& e) {
80553       {
80554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80555       };
80556     } catch (Dali::DaliException e) {
80557       {
80558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80559       };
80560     } catch (...) {
80561       {
80562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80563       };
80564     }
80565   }
80566
80567   jresult = result;
80568   return jresult;
80569 }
80570
80571
80572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
80573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80574   float arg2 ;
80575
80576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80577   arg2 = (float)jarg2;
80578   {
80579     try {
80580       (arg1)->SetFrictionCoefficient(arg2);
80581     } catch (std::out_of_range& e) {
80582       {
80583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80584       };
80585     } catch (std::exception& e) {
80586       {
80587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80588       };
80589     } catch (Dali::DaliException e) {
80590       {
80591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80592       };
80593     } catch (...) {
80594       {
80595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80596       };
80597     }
80598   }
80599
80600 }
80601
80602
80603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
80604   float jresult ;
80605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80606   float result;
80607
80608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80609   {
80610     try {
80611       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
80612     } catch (std::out_of_range& e) {
80613       {
80614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80615       };
80616     } catch (std::exception& e) {
80617       {
80618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80619       };
80620     } catch (Dali::DaliException e) {
80621       {
80622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80623       };
80624     } catch (...) {
80625       {
80626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80627       };
80628     }
80629   }
80630
80631   jresult = result;
80632   return jresult;
80633 }
80634
80635
80636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
80637   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80638   float arg2 ;
80639
80640   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80641   arg2 = (float)jarg2;
80642   {
80643     try {
80644       (arg1)->SetFlickSpeedCoefficient(arg2);
80645     } catch (std::out_of_range& e) {
80646       {
80647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80648       };
80649     } catch (std::exception& e) {
80650       {
80651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80652       };
80653     } catch (Dali::DaliException e) {
80654       {
80655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80656       };
80657     } catch (...) {
80658       {
80659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80660       };
80661     }
80662   }
80663
80664 }
80665
80666
80667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
80668   void * jresult ;
80669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80670   Dali::Vector2 result;
80671
80672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80673   {
80674     try {
80675       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
80676     } catch (std::out_of_range& e) {
80677       {
80678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80679       };
80680     } catch (std::exception& e) {
80681       {
80682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80683       };
80684     } catch (Dali::DaliException e) {
80685       {
80686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80687       };
80688     } catch (...) {
80689       {
80690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80691       };
80692     }
80693   }
80694
80695   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80696   return jresult;
80697 }
80698
80699
80700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
80701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80702   Dali::Vector2 *arg2 = 0 ;
80703
80704   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80705   arg2 = (Dali::Vector2 *)jarg2;
80706   if (!arg2) {
80707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
80708     return ;
80709   }
80710   {
80711     try {
80712       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
80713     } catch (std::out_of_range& e) {
80714       {
80715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80716       };
80717     } catch (std::exception& e) {
80718       {
80719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80720       };
80721     } catch (Dali::DaliException e) {
80722       {
80723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80724       };
80725     } catch (...) {
80726       {
80727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80728       };
80729     }
80730   }
80731
80732 }
80733
80734
80735 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
80736   float jresult ;
80737   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80738   float result;
80739
80740   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80741   {
80742     try {
80743       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
80744     } catch (std::out_of_range& e) {
80745       {
80746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80747       };
80748     } catch (std::exception& e) {
80749       {
80750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80751       };
80752     } catch (Dali::DaliException e) {
80753       {
80754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80755       };
80756     } catch (...) {
80757       {
80758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80759       };
80760     }
80761   }
80762
80763   jresult = result;
80764   return jresult;
80765 }
80766
80767
80768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
80769   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80770   float arg2 ;
80771
80772   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80773   arg2 = (float)jarg2;
80774   {
80775     try {
80776       (arg1)->SetMinimumSpeedForFlick(arg2);
80777     } catch (std::out_of_range& e) {
80778       {
80779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80780       };
80781     } catch (std::exception& e) {
80782       {
80783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80784       };
80785     } catch (Dali::DaliException e) {
80786       {
80787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80788       };
80789     } catch (...) {
80790       {
80791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80792       };
80793     }
80794   }
80795
80796 }
80797
80798
80799 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
80800   float jresult ;
80801   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80802   float result;
80803
80804   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80805   {
80806     try {
80807       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
80808     } catch (std::out_of_range& e) {
80809       {
80810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80811       };
80812     } catch (std::exception& e) {
80813       {
80814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80815       };
80816     } catch (Dali::DaliException e) {
80817       {
80818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80819       };
80820     } catch (...) {
80821       {
80822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80823       };
80824     }
80825   }
80826
80827   jresult = result;
80828   return jresult;
80829 }
80830
80831
80832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
80833   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80834   float arg2 ;
80835
80836   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80837   arg2 = (float)jarg2;
80838   {
80839     try {
80840       (arg1)->SetMaxFlickSpeed(arg2);
80841     } catch (std::out_of_range& e) {
80842       {
80843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80844       };
80845     } catch (std::exception& e) {
80846       {
80847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80848       };
80849     } catch (Dali::DaliException e) {
80850       {
80851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80852       };
80853     } catch (...) {
80854       {
80855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80856       };
80857     }
80858   }
80859
80860 }
80861
80862
80863 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
80864   void * jresult ;
80865   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80866   Dali::Vector2 result;
80867
80868   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80869   {
80870     try {
80871       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
80872     } catch (std::out_of_range& e) {
80873       {
80874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80875       };
80876     } catch (std::exception& e) {
80877       {
80878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80879       };
80880     } catch (Dali::DaliException e) {
80881       {
80882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80883       };
80884     } catch (...) {
80885       {
80886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80887       };
80888     }
80889   }
80890
80891   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80892   return jresult;
80893 }
80894
80895
80896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
80897   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80898   Dali::Vector2 arg2 ;
80899   Dali::Vector2 *argp2 ;
80900
80901   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80902   argp2 = (Dali::Vector2 *)jarg2;
80903   if (!argp2) {
80904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
80905     return ;
80906   }
80907   arg2 = *argp2;
80908   {
80909     try {
80910       (arg1)->SetWheelScrollDistanceStep(arg2);
80911     } catch (std::out_of_range& e) {
80912       {
80913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80914       };
80915     } catch (std::exception& e) {
80916       {
80917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80918       };
80919     } catch (Dali::DaliException e) {
80920       {
80921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80922       };
80923     } catch (...) {
80924       {
80925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80926       };
80927     }
80928   }
80929
80930 }
80931
80932
80933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
80934   void * jresult ;
80935   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80936   Dali::Vector2 result;
80937
80938   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80939   {
80940     try {
80941       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
80942     } catch (std::out_of_range& e) {
80943       {
80944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80945       };
80946     } catch (std::exception& e) {
80947       {
80948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80949       };
80950     } catch (Dali::DaliException e) {
80951       {
80952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80953       };
80954     } catch (...) {
80955       {
80956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80957       };
80958     }
80959   }
80960
80961   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80962   return jresult;
80963 }
80964
80965
80966 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
80967   unsigned int jresult ;
80968   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
80969   unsigned int result;
80970
80971   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
80972   {
80973     try {
80974       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
80975     } catch (std::out_of_range& e) {
80976       {
80977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80978       };
80979     } catch (std::exception& e) {
80980       {
80981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80982       };
80983     } catch (Dali::DaliException e) {
80984       {
80985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80986       };
80987     } catch (...) {
80988       {
80989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80990       };
80991     }
80992   }
80993
80994   jresult = result;
80995   return jresult;
80996 }
80997
80998
80999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
81000   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81001   Dali::Vector2 *arg2 = 0 ;
81002
81003   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81004   arg2 = (Dali::Vector2 *)jarg2;
81005   if (!arg2) {
81006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81007     return ;
81008   }
81009   {
81010     try {
81011       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
81012     } catch (std::out_of_range& e) {
81013       {
81014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81015       };
81016     } catch (std::exception& e) {
81017       {
81018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81019       };
81020     } catch (Dali::DaliException e) {
81021       {
81022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81023       };
81024     } catch (...) {
81025       {
81026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81027       };
81028     }
81029   }
81030
81031 }
81032
81033
81034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
81035   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81036   Dali::Vector2 *arg2 = 0 ;
81037   float arg3 ;
81038
81039   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81040   arg2 = (Dali::Vector2 *)jarg2;
81041   if (!arg2) {
81042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81043     return ;
81044   }
81045   arg3 = (float)jarg3;
81046   {
81047     try {
81048       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
81049     } catch (std::out_of_range& e) {
81050       {
81051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81052       };
81053     } catch (std::exception& e) {
81054       {
81055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81056       };
81057     } catch (Dali::DaliException e) {
81058       {
81059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81060       };
81061     } catch (...) {
81062       {
81063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81064       };
81065     }
81066   }
81067
81068 }
81069
81070
81071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
81072   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81073   Dali::Vector2 *arg2 = 0 ;
81074   float arg3 ;
81075   Dali::AlphaFunction arg4 ;
81076   Dali::AlphaFunction *argp4 ;
81077
81078   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81079   arg2 = (Dali::Vector2 *)jarg2;
81080   if (!arg2) {
81081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81082     return ;
81083   }
81084   arg3 = (float)jarg3;
81085   argp4 = (Dali::AlphaFunction *)jarg4;
81086   if (!argp4) {
81087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81088     return ;
81089   }
81090   arg4 = *argp4;
81091   {
81092     try {
81093       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
81094     } catch (std::out_of_range& e) {
81095       {
81096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81097       };
81098     } catch (std::exception& e) {
81099       {
81100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81101       };
81102     } catch (Dali::DaliException e) {
81103       {
81104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81105       };
81106     } catch (...) {
81107       {
81108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81109       };
81110     }
81111   }
81112
81113 }
81114
81115
81116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
81117   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81118   Dali::Vector2 *arg2 = 0 ;
81119   float arg3 ;
81120   Dali::Toolkit::DirectionBias arg4 ;
81121   Dali::Toolkit::DirectionBias arg5 ;
81122
81123   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81124   arg2 = (Dali::Vector2 *)jarg2;
81125   if (!arg2) {
81126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81127     return ;
81128   }
81129   arg3 = (float)jarg3;
81130   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81131   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81132   {
81133     try {
81134       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
81135     } catch (std::out_of_range& e) {
81136       {
81137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81138       };
81139     } catch (std::exception& e) {
81140       {
81141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81142       };
81143     } catch (Dali::DaliException e) {
81144       {
81145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81146       };
81147     } catch (...) {
81148       {
81149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81150       };
81151     }
81152   }
81153
81154 }
81155
81156
81157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
81158   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81159   Dali::Vector2 *arg2 = 0 ;
81160   float arg3 ;
81161   Dali::AlphaFunction arg4 ;
81162   Dali::Toolkit::DirectionBias arg5 ;
81163   Dali::Toolkit::DirectionBias arg6 ;
81164   Dali::AlphaFunction *argp4 ;
81165
81166   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81167   arg2 = (Dali::Vector2 *)jarg2;
81168   if (!arg2) {
81169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
81170     return ;
81171   }
81172   arg3 = (float)jarg3;
81173   argp4 = (Dali::AlphaFunction *)jarg4;
81174   if (!argp4) {
81175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
81176     return ;
81177   }
81178   arg4 = *argp4;
81179   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
81180   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
81181   {
81182     try {
81183       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
81184     } catch (std::out_of_range& e) {
81185       {
81186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81187       };
81188     } catch (std::exception& e) {
81189       {
81190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81191       };
81192     } catch (Dali::DaliException e) {
81193       {
81194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81195       };
81196     } catch (...) {
81197       {
81198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81199       };
81200     }
81201   }
81202
81203 }
81204
81205
81206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
81207   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81208   unsigned int arg2 ;
81209
81210   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81211   arg2 = (unsigned int)jarg2;
81212   {
81213     try {
81214       (arg1)->ScrollTo(arg2);
81215     } catch (std::out_of_range& e) {
81216       {
81217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81218       };
81219     } catch (std::exception& e) {
81220       {
81221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81222       };
81223     } catch (Dali::DaliException e) {
81224       {
81225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81226       };
81227     } catch (...) {
81228       {
81229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81230       };
81231     }
81232   }
81233
81234 }
81235
81236
81237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
81238   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81239   unsigned int arg2 ;
81240   float arg3 ;
81241
81242   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81243   arg2 = (unsigned int)jarg2;
81244   arg3 = (float)jarg3;
81245   {
81246     try {
81247       (arg1)->ScrollTo(arg2,arg3);
81248     } catch (std::out_of_range& e) {
81249       {
81250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81251       };
81252     } catch (std::exception& e) {
81253       {
81254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81255       };
81256     } catch (Dali::DaliException e) {
81257       {
81258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81259       };
81260     } catch (...) {
81261       {
81262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81263       };
81264     }
81265   }
81266
81267 }
81268
81269
81270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
81271   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81272   unsigned int arg2 ;
81273   float arg3 ;
81274   Dali::Toolkit::DirectionBias arg4 ;
81275
81276   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81277   arg2 = (unsigned int)jarg2;
81278   arg3 = (float)jarg3;
81279   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
81280   {
81281     try {
81282       (arg1)->ScrollTo(arg2,arg3,arg4);
81283     } catch (std::out_of_range& e) {
81284       {
81285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81286       };
81287     } catch (std::exception& e) {
81288       {
81289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81290       };
81291     } catch (Dali::DaliException e) {
81292       {
81293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81294       };
81295     } catch (...) {
81296       {
81297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81298       };
81299     }
81300   }
81301
81302 }
81303
81304
81305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
81306   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81307   Dali::Actor *arg2 = 0 ;
81308
81309   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81310   arg2 = (Dali::Actor *)jarg2;
81311   if (!arg2) {
81312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81313     return ;
81314   }
81315   {
81316     try {
81317       (arg1)->ScrollTo(*arg2);
81318     } catch (std::out_of_range& e) {
81319       {
81320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81321       };
81322     } catch (std::exception& e) {
81323       {
81324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81325       };
81326     } catch (Dali::DaliException e) {
81327       {
81328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81329       };
81330     } catch (...) {
81331       {
81332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81333       };
81334     }
81335   }
81336
81337 }
81338
81339
81340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
81341   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81342   Dali::Actor *arg2 = 0 ;
81343   float arg3 ;
81344
81345   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81346   arg2 = (Dali::Actor *)jarg2;
81347   if (!arg2) {
81348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
81349     return ;
81350   }
81351   arg3 = (float)jarg3;
81352   {
81353     try {
81354       (arg1)->ScrollTo(*arg2,arg3);
81355     } catch (std::out_of_range& e) {
81356       {
81357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81358       };
81359     } catch (std::exception& e) {
81360       {
81361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81362       };
81363     } catch (Dali::DaliException e) {
81364       {
81365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81366       };
81367     } catch (...) {
81368       {
81369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81370       };
81371     }
81372   }
81373
81374 }
81375
81376
81377 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
81378   unsigned int jresult ;
81379   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81380   bool result;
81381
81382   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81383   {
81384     try {
81385       result = (bool)(arg1)->ScrollToSnapPoint();
81386     } catch (std::out_of_range& e) {
81387       {
81388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81389       };
81390     } catch (std::exception& e) {
81391       {
81392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81393       };
81394     } catch (Dali::DaliException e) {
81395       {
81396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81397       };
81398     } catch (...) {
81399       {
81400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81401       };
81402     }
81403   }
81404
81405   jresult = result;
81406   return jresult;
81407 }
81408
81409
81410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
81411   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81412   Dali::Constraint arg2 ;
81413   Dali::Constraint *argp2 ;
81414
81415   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81416   argp2 = (Dali::Constraint *)jarg2;
81417   if (!argp2) {
81418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
81419     return ;
81420   }
81421   arg2 = *argp2;
81422   {
81423     try {
81424       (arg1)->ApplyConstraintToChildren(arg2);
81425     } catch (std::out_of_range& e) {
81426       {
81427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81428       };
81429     } catch (std::exception& e) {
81430       {
81431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81432       };
81433     } catch (Dali::DaliException e) {
81434       {
81435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81436       };
81437     } catch (...) {
81438       {
81439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81440       };
81441     }
81442   }
81443
81444 }
81445
81446
81447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
81448   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81449
81450   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81451   {
81452     try {
81453       (arg1)->RemoveConstraintsFromChildren();
81454     } catch (std::out_of_range& e) {
81455       {
81456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81457       };
81458     } catch (std::exception& e) {
81459       {
81460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81461       };
81462     } catch (Dali::DaliException e) {
81463       {
81464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81465       };
81466     } catch (...) {
81467       {
81468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81469       };
81470     }
81471   }
81472
81473 }
81474
81475
81476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
81477   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81478   Dali::Toolkit::ScrollViewEffect arg2 ;
81479   Dali::Toolkit::ScrollViewEffect *argp2 ;
81480
81481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81482   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81483   if (!argp2) {
81484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81485     return ;
81486   }
81487   arg2 = *argp2;
81488   {
81489     try {
81490       (arg1)->ApplyEffect(arg2);
81491     } catch (std::out_of_range& e) {
81492       {
81493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81494       };
81495     } catch (std::exception& e) {
81496       {
81497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81498       };
81499     } catch (Dali::DaliException e) {
81500       {
81501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81502       };
81503     } catch (...) {
81504       {
81505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81506       };
81507     }
81508   }
81509
81510 }
81511
81512
81513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
81514   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81515   Dali::Toolkit::ScrollViewEffect arg2 ;
81516   Dali::Toolkit::ScrollViewEffect *argp2 ;
81517
81518   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81519   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
81520   if (!argp2) {
81521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
81522     return ;
81523   }
81524   arg2 = *argp2;
81525   {
81526     try {
81527       (arg1)->RemoveEffect(arg2);
81528     } catch (std::out_of_range& e) {
81529       {
81530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81531       };
81532     } catch (std::exception& e) {
81533       {
81534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81535       };
81536     } catch (Dali::DaliException e) {
81537       {
81538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81539       };
81540     } catch (...) {
81541       {
81542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81543       };
81544     }
81545   }
81546
81547 }
81548
81549
81550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
81551   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81552
81553   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81554   {
81555     try {
81556       (arg1)->RemoveAllEffects();
81557     } catch (std::out_of_range& e) {
81558       {
81559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81560       };
81561     } catch (std::exception& e) {
81562       {
81563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81564       };
81565     } catch (Dali::DaliException e) {
81566       {
81567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81568       };
81569     } catch (...) {
81570       {
81571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81572       };
81573     }
81574   }
81575
81576 }
81577
81578
81579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
81580   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81581   Dali::Actor arg2 ;
81582   Dali::Actor *argp2 ;
81583
81584   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81585   argp2 = (Dali::Actor *)jarg2;
81586   if (!argp2) {
81587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81588     return ;
81589   }
81590   arg2 = *argp2;
81591   {
81592     try {
81593       (arg1)->BindActor(arg2);
81594     } catch (std::out_of_range& e) {
81595       {
81596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81597       };
81598     } catch (std::exception& e) {
81599       {
81600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81601       };
81602     } catch (Dali::DaliException e) {
81603       {
81604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81605       };
81606     } catch (...) {
81607       {
81608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81609       };
81610     }
81611   }
81612
81613 }
81614
81615
81616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
81617   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81618   Dali::Actor arg2 ;
81619   Dali::Actor *argp2 ;
81620
81621   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81622   argp2 = (Dali::Actor *)jarg2;
81623   if (!argp2) {
81624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
81625     return ;
81626   }
81627   arg2 = *argp2;
81628   {
81629     try {
81630       (arg1)->UnbindActor(arg2);
81631     } catch (std::out_of_range& e) {
81632       {
81633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81634       };
81635     } catch (std::exception& e) {
81636       {
81637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81638       };
81639     } catch (Dali::DaliException e) {
81640       {
81641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81642       };
81643     } catch (...) {
81644       {
81645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81646       };
81647     }
81648   }
81649
81650 }
81651
81652
81653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
81654   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81655   Dali::Radian arg2 ;
81656   Dali::Radian arg3 ;
81657   Dali::Radian *argp2 ;
81658   Dali::Radian *argp3 ;
81659
81660   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81661   argp2 = (Dali::Radian *)jarg2;
81662   if (!argp2) {
81663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81664     return ;
81665   }
81666   arg2 = *argp2;
81667   argp3 = (Dali::Radian *)jarg3;
81668   if (!argp3) {
81669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81670     return ;
81671   }
81672   arg3 = *argp3;
81673   {
81674     try {
81675       (arg1)->SetScrollingDirection(arg2,arg3);
81676     } catch (std::out_of_range& e) {
81677       {
81678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81679       };
81680     } catch (std::exception& e) {
81681       {
81682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81683       };
81684     } catch (Dali::DaliException e) {
81685       {
81686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81687       };
81688     } catch (...) {
81689       {
81690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81691       };
81692     }
81693   }
81694
81695 }
81696
81697
81698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
81699   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81700   Dali::Radian arg2 ;
81701   Dali::Radian *argp2 ;
81702
81703   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81704   argp2 = (Dali::Radian *)jarg2;
81705   if (!argp2) {
81706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81707     return ;
81708   }
81709   arg2 = *argp2;
81710   {
81711     try {
81712       (arg1)->SetScrollingDirection(arg2);
81713     } catch (std::out_of_range& e) {
81714       {
81715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81716       };
81717     } catch (std::exception& e) {
81718       {
81719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81720       };
81721     } catch (Dali::DaliException e) {
81722       {
81723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81724       };
81725     } catch (...) {
81726       {
81727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81728       };
81729     }
81730   }
81731
81732 }
81733
81734
81735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
81736   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81737   Dali::Radian arg2 ;
81738   Dali::Radian *argp2 ;
81739
81740   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81741   argp2 = (Dali::Radian *)jarg2;
81742   if (!argp2) {
81743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
81744     return ;
81745   }
81746   arg2 = *argp2;
81747   {
81748     try {
81749       (arg1)->RemoveScrollingDirection(arg2);
81750     } catch (std::out_of_range& e) {
81751       {
81752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81753       };
81754     } catch (std::exception& e) {
81755       {
81756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81757       };
81758     } catch (Dali::DaliException e) {
81759       {
81760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81761       };
81762     } catch (...) {
81763       {
81764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81765       };
81766     }
81767   }
81768
81769 }
81770
81771
81772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
81773   void * jresult ;
81774   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
81775   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
81776
81777   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
81778   {
81779     try {
81780       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
81781     } catch (std::out_of_range& e) {
81782       {
81783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81784       };
81785     } catch (std::exception& e) {
81786       {
81787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81788       };
81789     } catch (Dali::DaliException e) {
81790       {
81791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81792       };
81793     } catch (...) {
81794       {
81795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81796       };
81797     }
81798   }
81799
81800   jresult = (void *)result;
81801   return jresult;
81802 }
81803
81804
81805 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
81806   int jresult ;
81807   int result;
81808
81809   result = (int)Dali::Toolkit::TableView::Property::ROWS;
81810   jresult = (int)result;
81811   return jresult;
81812 }
81813
81814
81815 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
81816   int jresult ;
81817   int result;
81818
81819   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
81820   jresult = (int)result;
81821   return jresult;
81822 }
81823
81824
81825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
81826   int jresult ;
81827   int result;
81828
81829   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
81830   jresult = (int)result;
81831   return jresult;
81832 }
81833
81834
81835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
81836   int jresult ;
81837   int result;
81838
81839   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
81840   jresult = (int)result;
81841   return jresult;
81842 }
81843
81844
81845 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
81846   int jresult ;
81847   int result;
81848
81849   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
81850   jresult = (int)result;
81851   return jresult;
81852 }
81853
81854
81855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
81856   void * jresult ;
81857   Dali::Toolkit::TableView::Property *result = 0 ;
81858
81859   {
81860     try {
81861       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
81862     } catch (std::out_of_range& e) {
81863       {
81864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81865       };
81866     } catch (std::exception& e) {
81867       {
81868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81869       };
81870     } catch (Dali::DaliException e) {
81871       {
81872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81873       };
81874     } catch (...) {
81875       {
81876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81877       };
81878     }
81879   }
81880
81881   jresult = (void *)result;
81882   return jresult;
81883 }
81884
81885
81886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
81887   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
81888
81889   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
81890   {
81891     try {
81892       delete arg1;
81893     } catch (std::out_of_range& e) {
81894       {
81895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81896       };
81897     } catch (std::exception& e) {
81898       {
81899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81900       };
81901     } catch (Dali::DaliException e) {
81902       {
81903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81904       };
81905     } catch (...) {
81906       {
81907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81908       };
81909     }
81910   }
81911
81912 }
81913
81914
81915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
81916   int jresult ;
81917   int result;
81918
81919   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
81920   jresult = (int)result;
81921   return jresult;
81922 }
81923
81924
81925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
81926   int jresult ;
81927   int result;
81928
81929   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
81930   jresult = (int)result;
81931   return jresult;
81932 }
81933
81934
81935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
81936   int jresult ;
81937   int result;
81938
81939   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
81940   jresult = (int)result;
81941   return jresult;
81942 }
81943
81944
81945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
81946   int jresult ;
81947   int result;
81948
81949   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
81950   jresult = (int)result;
81951   return jresult;
81952 }
81953
81954
81955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
81956   int jresult ;
81957   int result;
81958
81959   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
81960   jresult = (int)result;
81961   return jresult;
81962 }
81963
81964
81965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
81966   void * jresult ;
81967   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
81968
81969   {
81970     try {
81971       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
81972     } catch (std::out_of_range& e) {
81973       {
81974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81975       };
81976     } catch (std::exception& e) {
81977       {
81978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81979       };
81980     } catch (Dali::DaliException e) {
81981       {
81982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81983       };
81984     } catch (...) {
81985       {
81986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81987       };
81988     }
81989   }
81990
81991   jresult = (void *)result;
81992   return jresult;
81993 }
81994
81995
81996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
81997   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
81998
81999   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
82000   {
82001     try {
82002       delete arg1;
82003     } catch (std::out_of_range& e) {
82004       {
82005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82006       };
82007     } catch (std::exception& e) {
82008       {
82009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82010       };
82011     } catch (Dali::DaliException e) {
82012       {
82013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82014       };
82015     } catch (...) {
82016       {
82017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82018       };
82019     }
82020   }
82021
82022 }
82023
82024
82025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
82026   void * jresult ;
82027   unsigned int arg1 ;
82028   unsigned int arg2 ;
82029   unsigned int arg3 ;
82030   unsigned int arg4 ;
82031   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82032
82033   arg1 = (unsigned int)jarg1;
82034   arg2 = (unsigned int)jarg2;
82035   arg3 = (unsigned int)jarg3;
82036   arg4 = (unsigned int)jarg4;
82037   {
82038     try {
82039       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
82040     } catch (std::out_of_range& e) {
82041       {
82042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82043       };
82044     } catch (std::exception& e) {
82045       {
82046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82047       };
82048     } catch (Dali::DaliException e) {
82049       {
82050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82051       };
82052     } catch (...) {
82053       {
82054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82055       };
82056     }
82057   }
82058
82059   jresult = (void *)result;
82060   return jresult;
82061 }
82062
82063
82064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
82065   void * jresult ;
82066   unsigned int arg1 ;
82067   unsigned int arg2 ;
82068   unsigned int arg3 ;
82069   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82070
82071   arg1 = (unsigned int)jarg1;
82072   arg2 = (unsigned int)jarg2;
82073   arg3 = (unsigned int)jarg3;
82074   {
82075     try {
82076       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
82077     } catch (std::out_of_range& e) {
82078       {
82079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82080       };
82081     } catch (std::exception& e) {
82082       {
82083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82084       };
82085     } catch (Dali::DaliException e) {
82086       {
82087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82088       };
82089     } catch (...) {
82090       {
82091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82092       };
82093     }
82094   }
82095
82096   jresult = (void *)result;
82097   return jresult;
82098 }
82099
82100
82101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
82102   void * jresult ;
82103   unsigned int arg1 ;
82104   unsigned int arg2 ;
82105   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82106
82107   arg1 = (unsigned int)jarg1;
82108   arg2 = (unsigned int)jarg2;
82109   {
82110     try {
82111       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
82112     } catch (std::out_of_range& e) {
82113       {
82114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82115       };
82116     } catch (std::exception& e) {
82117       {
82118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82119       };
82120     } catch (Dali::DaliException e) {
82121       {
82122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82123       };
82124     } catch (...) {
82125       {
82126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82127       };
82128     }
82129   }
82130
82131   jresult = (void *)result;
82132   return jresult;
82133 }
82134
82135
82136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
82137   void * jresult ;
82138   unsigned int arg1 ;
82139   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82140
82141   arg1 = (unsigned int)jarg1;
82142   {
82143     try {
82144       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
82145     } catch (std::out_of_range& e) {
82146       {
82147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82148       };
82149     } catch (std::exception& e) {
82150       {
82151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82152       };
82153     } catch (Dali::DaliException e) {
82154       {
82155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82156       };
82157     } catch (...) {
82158       {
82159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82160       };
82161     }
82162   }
82163
82164   jresult = (void *)result;
82165   return jresult;
82166 }
82167
82168
82169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
82170   void * jresult ;
82171   Dali::Toolkit::TableView::CellPosition *result = 0 ;
82172
82173   {
82174     try {
82175       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
82176     } catch (std::out_of_range& e) {
82177       {
82178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82179       };
82180     } catch (std::exception& e) {
82181       {
82182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82183       };
82184     } catch (Dali::DaliException e) {
82185       {
82186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82187       };
82188     } catch (...) {
82189       {
82190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82191       };
82192     }
82193   }
82194
82195   jresult = (void *)result;
82196   return jresult;
82197 }
82198
82199
82200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
82201   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82202   unsigned int arg2 ;
82203
82204   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82205   arg2 = (unsigned int)jarg2;
82206   if (arg1) (arg1)->rowIndex = arg2;
82207 }
82208
82209
82210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
82211   unsigned int jresult ;
82212   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82213   unsigned int result;
82214
82215   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82216   result = (unsigned int) ((arg1)->rowIndex);
82217   jresult = result;
82218   return jresult;
82219 }
82220
82221
82222 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
82223   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82224   unsigned int arg2 ;
82225
82226   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82227   arg2 = (unsigned int)jarg2;
82228   if (arg1) (arg1)->columnIndex = arg2;
82229 }
82230
82231
82232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
82233   unsigned int jresult ;
82234   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82235   unsigned int result;
82236
82237   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82238   result = (unsigned int) ((arg1)->columnIndex);
82239   jresult = result;
82240   return jresult;
82241 }
82242
82243
82244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
82245   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82246   unsigned int arg2 ;
82247
82248   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82249   arg2 = (unsigned int)jarg2;
82250   if (arg1) (arg1)->rowSpan = arg2;
82251 }
82252
82253
82254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
82255   unsigned int jresult ;
82256   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82257   unsigned int result;
82258
82259   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82260   result = (unsigned int) ((arg1)->rowSpan);
82261   jresult = result;
82262   return jresult;
82263 }
82264
82265
82266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
82267   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82268   unsigned int arg2 ;
82269
82270   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82271   arg2 = (unsigned int)jarg2;
82272   if (arg1) (arg1)->columnSpan = arg2;
82273 }
82274
82275
82276 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
82277   unsigned int jresult ;
82278   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82279   unsigned int result;
82280
82281   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82282   result = (unsigned int) ((arg1)->columnSpan);
82283   jresult = result;
82284   return jresult;
82285 }
82286
82287
82288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
82289   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
82290
82291   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
82292   {
82293     try {
82294       delete arg1;
82295     } catch (std::out_of_range& e) {
82296       {
82297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82298       };
82299     } catch (std::exception& e) {
82300       {
82301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82302       };
82303     } catch (Dali::DaliException e) {
82304       {
82305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82306       };
82307     } catch (...) {
82308       {
82309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82310       };
82311     }
82312   }
82313
82314 }
82315
82316
82317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
82318   void * jresult ;
82319   Dali::Toolkit::TableView *result = 0 ;
82320
82321   {
82322     try {
82323       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
82324     } catch (std::out_of_range& e) {
82325       {
82326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82327       };
82328     } catch (std::exception& e) {
82329       {
82330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82331       };
82332     } catch (Dali::DaliException e) {
82333       {
82334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82335       };
82336     } catch (...) {
82337       {
82338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82339       };
82340     }
82341   }
82342
82343   jresult = (void *)result;
82344   return jresult;
82345 }
82346
82347
82348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
82349   void * jresult ;
82350   Dali::Toolkit::TableView *arg1 = 0 ;
82351   Dali::Toolkit::TableView *result = 0 ;
82352
82353   arg1 = (Dali::Toolkit::TableView *)jarg1;
82354   if (!arg1) {
82355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82356     return 0;
82357   }
82358   {
82359     try {
82360       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
82361     } catch (std::out_of_range& e) {
82362       {
82363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82364       };
82365     } catch (std::exception& e) {
82366       {
82367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82368       };
82369     } catch (Dali::DaliException e) {
82370       {
82371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82372       };
82373     } catch (...) {
82374       {
82375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82376       };
82377     }
82378   }
82379
82380   jresult = (void *)result;
82381   return jresult;
82382 }
82383
82384
82385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
82386   void * jresult ;
82387   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82388   Dali::Toolkit::TableView *arg2 = 0 ;
82389   Dali::Toolkit::TableView *result = 0 ;
82390
82391   arg1 = (Dali::Toolkit::TableView *)jarg1;
82392   arg2 = (Dali::Toolkit::TableView *)jarg2;
82393   if (!arg2) {
82394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
82395     return 0;
82396   }
82397   {
82398     try {
82399       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
82400     } catch (std::out_of_range& e) {
82401       {
82402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82403       };
82404     } catch (std::exception& e) {
82405       {
82406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82407       };
82408     } catch (Dali::DaliException e) {
82409       {
82410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82411       };
82412     } catch (...) {
82413       {
82414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82415       };
82416     }
82417   }
82418
82419   jresult = (void *)result;
82420   return jresult;
82421 }
82422
82423
82424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
82425   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82426
82427   arg1 = (Dali::Toolkit::TableView *)jarg1;
82428   {
82429     try {
82430       delete arg1;
82431     } catch (std::out_of_range& e) {
82432       {
82433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82434       };
82435     } catch (std::exception& e) {
82436       {
82437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82438       };
82439     } catch (Dali::DaliException e) {
82440       {
82441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82442       };
82443     } catch (...) {
82444       {
82445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82446       };
82447     }
82448   }
82449
82450 }
82451
82452
82453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
82454   void * jresult ;
82455   unsigned int arg1 ;
82456   unsigned int arg2 ;
82457   Dali::Toolkit::TableView result;
82458
82459   arg1 = (unsigned int)jarg1;
82460   arg2 = (unsigned int)jarg2;
82461   {
82462     try {
82463       result = Dali::Toolkit::TableView::New(arg1,arg2);
82464     } catch (std::out_of_range& e) {
82465       {
82466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82467       };
82468     } catch (std::exception& e) {
82469       {
82470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82471       };
82472     } catch (Dali::DaliException e) {
82473       {
82474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82475       };
82476     } catch (...) {
82477       {
82478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82479       };
82480     }
82481   }
82482
82483   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82484   return jresult;
82485 }
82486
82487
82488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
82489   void * jresult ;
82490   Dali::BaseHandle arg1 ;
82491   Dali::BaseHandle *argp1 ;
82492   Dali::Toolkit::TableView result;
82493
82494   argp1 = (Dali::BaseHandle *)jarg1;
82495   if (!argp1) {
82496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82497     return 0;
82498   }
82499   arg1 = *argp1;
82500   {
82501     try {
82502       result = Dali::Toolkit::TableView::DownCast(arg1);
82503     } catch (std::out_of_range& e) {
82504       {
82505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82506       };
82507     } catch (std::exception& e) {
82508       {
82509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82510       };
82511     } catch (Dali::DaliException e) {
82512       {
82513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82514       };
82515     } catch (...) {
82516       {
82517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82518       };
82519     }
82520   }
82521
82522   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
82523   return jresult;
82524 }
82525
82526
82527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
82528   unsigned int jresult ;
82529   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82530   Dali::Actor arg2 ;
82531   Dali::Toolkit::TableView::CellPosition arg3 ;
82532   Dali::Actor *argp2 ;
82533   Dali::Toolkit::TableView::CellPosition *argp3 ;
82534   bool result;
82535
82536   arg1 = (Dali::Toolkit::TableView *)jarg1;
82537   argp2 = (Dali::Actor *)jarg2;
82538   if (!argp2) {
82539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82540     return 0;
82541   }
82542   arg2 = *argp2;
82543   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82544   if (!argp3) {
82545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82546     return 0;
82547   }
82548   arg3 = *argp3;
82549   {
82550     try {
82551       result = (bool)(arg1)->AddChild(arg2,arg3);
82552     } catch (std::out_of_range& e) {
82553       {
82554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82555       };
82556     } catch (std::exception& e) {
82557       {
82558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82559       };
82560     } catch (Dali::DaliException e) {
82561       {
82562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82563       };
82564     } catch (...) {
82565       {
82566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82567       };
82568     }
82569   }
82570
82571   jresult = result;
82572   return jresult;
82573 }
82574
82575
82576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
82577   void * jresult ;
82578   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82579   Dali::Toolkit::TableView::CellPosition arg2 ;
82580   Dali::Toolkit::TableView::CellPosition *argp2 ;
82581   Dali::Actor result;
82582
82583   arg1 = (Dali::Toolkit::TableView *)jarg1;
82584   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82585   if (!argp2) {
82586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82587     return 0;
82588   }
82589   arg2 = *argp2;
82590   {
82591     try {
82592       result = (arg1)->GetChildAt(arg2);
82593     } catch (std::out_of_range& e) {
82594       {
82595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82596       };
82597     } catch (std::exception& e) {
82598       {
82599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82600       };
82601     } catch (Dali::DaliException e) {
82602       {
82603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82604       };
82605     } catch (...) {
82606       {
82607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82608       };
82609     }
82610   }
82611
82612   jresult = new Dali::Actor((const Dali::Actor &)result);
82613   return jresult;
82614 }
82615
82616
82617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
82618   void * jresult ;
82619   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82620   Dali::Toolkit::TableView::CellPosition arg2 ;
82621   Dali::Toolkit::TableView::CellPosition *argp2 ;
82622   Dali::Actor result;
82623
82624   arg1 = (Dali::Toolkit::TableView *)jarg1;
82625   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
82626   if (!argp2) {
82627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
82628     return 0;
82629   }
82630   arg2 = *argp2;
82631   {
82632     try {
82633       result = (arg1)->RemoveChildAt(arg2);
82634     } catch (std::out_of_range& e) {
82635       {
82636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82637       };
82638     } catch (std::exception& e) {
82639       {
82640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82641       };
82642     } catch (Dali::DaliException e) {
82643       {
82644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82645       };
82646     } catch (...) {
82647       {
82648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82649       };
82650     }
82651   }
82652
82653   jresult = new Dali::Actor((const Dali::Actor &)result);
82654   return jresult;
82655 }
82656
82657
82658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
82659   unsigned int jresult ;
82660   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82661   Dali::Actor arg2 ;
82662   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
82663   Dali::Actor *argp2 ;
82664   bool result;
82665
82666   arg1 = (Dali::Toolkit::TableView *)jarg1;
82667   argp2 = (Dali::Actor *)jarg2;
82668   if (!argp2) {
82669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82670     return 0;
82671   }
82672   arg2 = *argp2;
82673   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
82674   if (!arg3) {
82675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
82676     return 0;
82677   }
82678   {
82679     try {
82680       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
82681     } catch (std::out_of_range& e) {
82682       {
82683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82684       };
82685     } catch (std::exception& e) {
82686       {
82687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82688       };
82689     } catch (Dali::DaliException e) {
82690       {
82691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82692       };
82693     } catch (...) {
82694       {
82695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82696       };
82697     }
82698   }
82699
82700   jresult = result;
82701   return jresult;
82702 }
82703
82704
82705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
82706   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82707   unsigned int arg2 ;
82708
82709   arg1 = (Dali::Toolkit::TableView *)jarg1;
82710   arg2 = (unsigned int)jarg2;
82711   {
82712     try {
82713       (arg1)->InsertRow(arg2);
82714     } catch (std::out_of_range& e) {
82715       {
82716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82717       };
82718     } catch (std::exception& e) {
82719       {
82720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82721       };
82722     } catch (Dali::DaliException e) {
82723       {
82724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82725       };
82726     } catch (...) {
82727       {
82728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82729       };
82730     }
82731   }
82732
82733 }
82734
82735
82736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
82737   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82738   unsigned int arg2 ;
82739
82740   arg1 = (Dali::Toolkit::TableView *)jarg1;
82741   arg2 = (unsigned int)jarg2;
82742   {
82743     try {
82744       (arg1)->DeleteRow(arg2);
82745     } catch (std::out_of_range& e) {
82746       {
82747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82748       };
82749     } catch (std::exception& e) {
82750       {
82751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82752       };
82753     } catch (Dali::DaliException e) {
82754       {
82755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82756       };
82757     } catch (...) {
82758       {
82759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82760       };
82761     }
82762   }
82763
82764 }
82765
82766
82767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82768   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82769   unsigned int arg2 ;
82770   std::vector< Dali::Actor > *arg3 = 0 ;
82771
82772   arg1 = (Dali::Toolkit::TableView *)jarg1;
82773   arg2 = (unsigned int)jarg2;
82774   arg3 = (std::vector< Dali::Actor > *)jarg3;
82775   if (!arg3) {
82776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82777     return ;
82778   }
82779   {
82780     try {
82781       (arg1)->DeleteRow(arg2,*arg3);
82782     } catch (std::out_of_range& e) {
82783       {
82784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82785       };
82786     } catch (std::exception& e) {
82787       {
82788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82789       };
82790     } catch (Dali::DaliException e) {
82791       {
82792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82793       };
82794     } catch (...) {
82795       {
82796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82797       };
82798     }
82799   }
82800
82801 }
82802
82803
82804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
82805   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82806   unsigned int arg2 ;
82807
82808   arg1 = (Dali::Toolkit::TableView *)jarg1;
82809   arg2 = (unsigned int)jarg2;
82810   {
82811     try {
82812       (arg1)->InsertColumn(arg2);
82813     } catch (std::out_of_range& e) {
82814       {
82815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82816       };
82817     } catch (std::exception& e) {
82818       {
82819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82820       };
82821     } catch (Dali::DaliException e) {
82822       {
82823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82824       };
82825     } catch (...) {
82826       {
82827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82828       };
82829     }
82830   }
82831
82832 }
82833
82834
82835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
82836   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82837   unsigned int arg2 ;
82838
82839   arg1 = (Dali::Toolkit::TableView *)jarg1;
82840   arg2 = (unsigned int)jarg2;
82841   {
82842     try {
82843       (arg1)->DeleteColumn(arg2);
82844     } catch (std::out_of_range& e) {
82845       {
82846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82847       };
82848     } catch (std::exception& e) {
82849       {
82850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82851       };
82852     } catch (Dali::DaliException e) {
82853       {
82854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82855       };
82856     } catch (...) {
82857       {
82858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82859       };
82860     }
82861   }
82862
82863 }
82864
82865
82866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
82867   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82868   unsigned int arg2 ;
82869   std::vector< Dali::Actor > *arg3 = 0 ;
82870
82871   arg1 = (Dali::Toolkit::TableView *)jarg1;
82872   arg2 = (unsigned int)jarg2;
82873   arg3 = (std::vector< Dali::Actor > *)jarg3;
82874   if (!arg3) {
82875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82876     return ;
82877   }
82878   {
82879     try {
82880       (arg1)->DeleteColumn(arg2,*arg3);
82881     } catch (std::out_of_range& e) {
82882       {
82883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82884       };
82885     } catch (std::exception& e) {
82886       {
82887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82888       };
82889     } catch (Dali::DaliException e) {
82890       {
82891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82892       };
82893     } catch (...) {
82894       {
82895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82896       };
82897     }
82898   }
82899
82900 }
82901
82902
82903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
82904   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82905   unsigned int arg2 ;
82906   unsigned int arg3 ;
82907
82908   arg1 = (Dali::Toolkit::TableView *)jarg1;
82909   arg2 = (unsigned int)jarg2;
82910   arg3 = (unsigned int)jarg3;
82911   {
82912     try {
82913       (arg1)->Resize(arg2,arg3);
82914     } catch (std::out_of_range& e) {
82915       {
82916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82917       };
82918     } catch (std::exception& e) {
82919       {
82920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82921       };
82922     } catch (Dali::DaliException e) {
82923       {
82924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82925       };
82926     } catch (...) {
82927       {
82928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82929       };
82930     }
82931   }
82932
82933 }
82934
82935
82936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
82937   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82938   unsigned int arg2 ;
82939   unsigned int arg3 ;
82940   std::vector< Dali::Actor > *arg4 = 0 ;
82941
82942   arg1 = (Dali::Toolkit::TableView *)jarg1;
82943   arg2 = (unsigned int)jarg2;
82944   arg3 = (unsigned int)jarg3;
82945   arg4 = (std::vector< Dali::Actor > *)jarg4;
82946   if (!arg4) {
82947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
82948     return ;
82949   }
82950   {
82951     try {
82952       (arg1)->Resize(arg2,arg3,*arg4);
82953     } catch (std::out_of_range& e) {
82954       {
82955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82956       };
82957     } catch (std::exception& e) {
82958       {
82959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82960       };
82961     } catch (Dali::DaliException e) {
82962       {
82963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82964       };
82965     } catch (...) {
82966       {
82967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82968       };
82969     }
82970   }
82971
82972 }
82973
82974
82975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
82976   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
82977   Dali::Size arg2 ;
82978   Dali::Size *argp2 ;
82979
82980   arg1 = (Dali::Toolkit::TableView *)jarg1;
82981   argp2 = (Dali::Size *)jarg2;
82982   if (!argp2) {
82983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
82984     return ;
82985   }
82986   arg2 = *argp2;
82987   {
82988     try {
82989       (arg1)->SetCellPadding(arg2);
82990     } catch (std::out_of_range& e) {
82991       {
82992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82993       };
82994     } catch (std::exception& e) {
82995       {
82996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82997       };
82998     } catch (Dali::DaliException e) {
82999       {
83000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83001       };
83002     } catch (...) {
83003       {
83004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83005       };
83006     }
83007   }
83008
83009 }
83010
83011
83012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
83013   void * jresult ;
83014   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83015   Dali::Size result;
83016
83017   arg1 = (Dali::Toolkit::TableView *)jarg1;
83018   {
83019     try {
83020       result = (arg1)->GetCellPadding();
83021     } catch (std::out_of_range& e) {
83022       {
83023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83024       };
83025     } catch (std::exception& e) {
83026       {
83027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83028       };
83029     } catch (Dali::DaliException e) {
83030       {
83031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83032       };
83033     } catch (...) {
83034       {
83035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83036       };
83037     }
83038   }
83039
83040   jresult = new Dali::Size((const Dali::Size &)result);
83041   return jresult;
83042 }
83043
83044
83045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
83046   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83047   unsigned int arg2 ;
83048
83049   arg1 = (Dali::Toolkit::TableView *)jarg1;
83050   arg2 = (unsigned int)jarg2;
83051   {
83052     try {
83053       (arg1)->SetFitHeight(arg2);
83054     } catch (std::out_of_range& e) {
83055       {
83056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83057       };
83058     } catch (std::exception& e) {
83059       {
83060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83061       };
83062     } catch (Dali::DaliException e) {
83063       {
83064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83065       };
83066     } catch (...) {
83067       {
83068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83069       };
83070     }
83071   }
83072
83073 }
83074
83075
83076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
83077   unsigned int jresult ;
83078   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83079   unsigned int arg2 ;
83080   bool result;
83081
83082   arg1 = (Dali::Toolkit::TableView *)jarg1;
83083   arg2 = (unsigned int)jarg2;
83084   {
83085     try {
83086       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
83087     } catch (std::out_of_range& e) {
83088       {
83089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83090       };
83091     } catch (std::exception& e) {
83092       {
83093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83094       };
83095     } catch (Dali::DaliException e) {
83096       {
83097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83098       };
83099     } catch (...) {
83100       {
83101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83102       };
83103     }
83104   }
83105
83106   jresult = result;
83107   return jresult;
83108 }
83109
83110
83111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
83112   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83113   unsigned int arg2 ;
83114
83115   arg1 = (Dali::Toolkit::TableView *)jarg1;
83116   arg2 = (unsigned int)jarg2;
83117   {
83118     try {
83119       (arg1)->SetFitWidth(arg2);
83120     } catch (std::out_of_range& e) {
83121       {
83122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83123       };
83124     } catch (std::exception& e) {
83125       {
83126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83127       };
83128     } catch (Dali::DaliException e) {
83129       {
83130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83131       };
83132     } catch (...) {
83133       {
83134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83135       };
83136     }
83137   }
83138
83139 }
83140
83141
83142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
83143   unsigned int jresult ;
83144   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83145   unsigned int arg2 ;
83146   bool result;
83147
83148   arg1 = (Dali::Toolkit::TableView *)jarg1;
83149   arg2 = (unsigned int)jarg2;
83150   {
83151     try {
83152       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
83153     } catch (std::out_of_range& e) {
83154       {
83155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83156       };
83157     } catch (std::exception& e) {
83158       {
83159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83160       };
83161     } catch (Dali::DaliException e) {
83162       {
83163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83164       };
83165     } catch (...) {
83166       {
83167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83168       };
83169     }
83170   }
83171
83172   jresult = result;
83173   return jresult;
83174 }
83175
83176
83177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83178   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83179   unsigned int arg2 ;
83180   float arg3 ;
83181
83182   arg1 = (Dali::Toolkit::TableView *)jarg1;
83183   arg2 = (unsigned int)jarg2;
83184   arg3 = (float)jarg3;
83185   {
83186     try {
83187       (arg1)->SetFixedHeight(arg2,arg3);
83188     } catch (std::out_of_range& e) {
83189       {
83190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83191       };
83192     } catch (std::exception& e) {
83193       {
83194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83195       };
83196     } catch (Dali::DaliException e) {
83197       {
83198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83199       };
83200     } catch (...) {
83201       {
83202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83203       };
83204     }
83205   }
83206
83207 }
83208
83209
83210 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
83211   float jresult ;
83212   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83213   unsigned int arg2 ;
83214   float result;
83215
83216   arg1 = (Dali::Toolkit::TableView *)jarg1;
83217   arg2 = (unsigned int)jarg2;
83218   {
83219     try {
83220       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
83221     } catch (std::out_of_range& e) {
83222       {
83223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83224       };
83225     } catch (std::exception& e) {
83226       {
83227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83228       };
83229     } catch (Dali::DaliException e) {
83230       {
83231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83232       };
83233     } catch (...) {
83234       {
83235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83236       };
83237     }
83238   }
83239
83240   jresult = result;
83241   return jresult;
83242 }
83243
83244
83245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
83246   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83247   unsigned int arg2 ;
83248   float arg3 ;
83249
83250   arg1 = (Dali::Toolkit::TableView *)jarg1;
83251   arg2 = (unsigned int)jarg2;
83252   arg3 = (float)jarg3;
83253   {
83254     try {
83255       (arg1)->SetRelativeHeight(arg2,arg3);
83256     } catch (std::out_of_range& e) {
83257       {
83258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83259       };
83260     } catch (std::exception& e) {
83261       {
83262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83263       };
83264     } catch (Dali::DaliException e) {
83265       {
83266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83267       };
83268     } catch (...) {
83269       {
83270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83271       };
83272     }
83273   }
83274
83275 }
83276
83277
83278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
83279   float jresult ;
83280   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83281   unsigned int arg2 ;
83282   float result;
83283
83284   arg1 = (Dali::Toolkit::TableView *)jarg1;
83285   arg2 = (unsigned int)jarg2;
83286   {
83287     try {
83288       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
83289     } catch (std::out_of_range& e) {
83290       {
83291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83292       };
83293     } catch (std::exception& e) {
83294       {
83295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83296       };
83297     } catch (Dali::DaliException e) {
83298       {
83299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83300       };
83301     } catch (...) {
83302       {
83303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83304       };
83305     }
83306   }
83307
83308   jresult = result;
83309   return jresult;
83310 }
83311
83312
83313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83314   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83315   unsigned int arg2 ;
83316   float arg3 ;
83317
83318   arg1 = (Dali::Toolkit::TableView *)jarg1;
83319   arg2 = (unsigned int)jarg2;
83320   arg3 = (float)jarg3;
83321   {
83322     try {
83323       (arg1)->SetFixedWidth(arg2,arg3);
83324     } catch (std::out_of_range& e) {
83325       {
83326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83327       };
83328     } catch (std::exception& e) {
83329       {
83330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83331       };
83332     } catch (Dali::DaliException e) {
83333       {
83334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83335       };
83336     } catch (...) {
83337       {
83338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83339       };
83340     }
83341   }
83342
83343 }
83344
83345
83346 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
83347   float jresult ;
83348   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83349   unsigned int arg2 ;
83350   float result;
83351
83352   arg1 = (Dali::Toolkit::TableView *)jarg1;
83353   arg2 = (unsigned int)jarg2;
83354   {
83355     try {
83356       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
83357     } catch (std::out_of_range& e) {
83358       {
83359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83360       };
83361     } catch (std::exception& e) {
83362       {
83363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83364       };
83365     } catch (Dali::DaliException e) {
83366       {
83367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83368       };
83369     } catch (...) {
83370       {
83371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83372       };
83373     }
83374   }
83375
83376   jresult = result;
83377   return jresult;
83378 }
83379
83380
83381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
83382   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83383   unsigned int arg2 ;
83384   float arg3 ;
83385
83386   arg1 = (Dali::Toolkit::TableView *)jarg1;
83387   arg2 = (unsigned int)jarg2;
83388   arg3 = (float)jarg3;
83389   {
83390     try {
83391       (arg1)->SetRelativeWidth(arg2,arg3);
83392     } catch (std::out_of_range& e) {
83393       {
83394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83395       };
83396     } catch (std::exception& e) {
83397       {
83398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83399       };
83400     } catch (Dali::DaliException e) {
83401       {
83402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83403       };
83404     } catch (...) {
83405       {
83406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83407       };
83408     }
83409   }
83410
83411 }
83412
83413
83414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
83415   float jresult ;
83416   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83417   unsigned int arg2 ;
83418   float result;
83419
83420   arg1 = (Dali::Toolkit::TableView *)jarg1;
83421   arg2 = (unsigned int)jarg2;
83422   {
83423     try {
83424       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
83425     } catch (std::out_of_range& e) {
83426       {
83427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83428       };
83429     } catch (std::exception& e) {
83430       {
83431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83432       };
83433     } catch (Dali::DaliException e) {
83434       {
83435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83436       };
83437     } catch (...) {
83438       {
83439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83440       };
83441     }
83442   }
83443
83444   jresult = result;
83445   return jresult;
83446 }
83447
83448
83449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
83450   unsigned int jresult ;
83451   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83452   unsigned int result;
83453
83454   arg1 = (Dali::Toolkit::TableView *)jarg1;
83455   {
83456     try {
83457       result = (unsigned int)(arg1)->GetRows();
83458     } catch (std::out_of_range& e) {
83459       {
83460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83461       };
83462     } catch (std::exception& e) {
83463       {
83464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83465       };
83466     } catch (Dali::DaliException e) {
83467       {
83468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83469       };
83470     } catch (...) {
83471       {
83472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83473       };
83474     }
83475   }
83476
83477   jresult = result;
83478   return jresult;
83479 }
83480
83481
83482 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
83483   unsigned int jresult ;
83484   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83485   unsigned int result;
83486
83487   arg1 = (Dali::Toolkit::TableView *)jarg1;
83488   {
83489     try {
83490       result = (unsigned int)(arg1)->GetColumns();
83491     } catch (std::out_of_range& e) {
83492       {
83493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83494       };
83495     } catch (std::exception& e) {
83496       {
83497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83498       };
83499     } catch (Dali::DaliException e) {
83500       {
83501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83502       };
83503     } catch (...) {
83504       {
83505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83506       };
83507     }
83508   }
83509
83510   jresult = result;
83511   return jresult;
83512 }
83513
83514
83515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
83516   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
83517   Dali::Toolkit::TableView::CellPosition arg2 ;
83518   Dali::HorizontalAlignment::Type arg3 ;
83519   Dali::VerticalAlignment::Type arg4 ;
83520   Dali::Toolkit::TableView::CellPosition *argp2 ;
83521
83522   arg1 = (Dali::Toolkit::TableView *)jarg1;
83523   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
83524   if (!argp2) {
83525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
83526     return ;
83527   }
83528   arg2 = *argp2;
83529   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
83530   arg4 = (Dali::VerticalAlignment::Type)jarg4;
83531   {
83532     try {
83533       (arg1)->SetCellAlignment(arg2,arg3,arg4);
83534     } catch (std::out_of_range& e) {
83535       {
83536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83537       };
83538     } catch (std::exception& e) {
83539       {
83540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83541       };
83542     } catch (Dali::DaliException e) {
83543       {
83544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83545       };
83546     } catch (...) {
83547       {
83548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83549       };
83550     }
83551   }
83552
83553 }
83554
83555
83556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
83557   unsigned int jresult ;
83558   unsigned int result;
83559
83560   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
83561   jresult = result;
83562   return jresult;
83563 }
83564
83565
83566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
83567   int jresult ;
83568   int result;
83569
83570   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
83571   jresult = (int)result;
83572   return jresult;
83573 }
83574
83575
83576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
83577   int jresult ;
83578   int result;
83579
83580   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
83581   jresult = (int)result;
83582   return jresult;
83583 }
83584
83585
83586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
83587   int jresult ;
83588   int result;
83589
83590   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
83591   jresult = (int)result;
83592   return jresult;
83593 }
83594
83595
83596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
83597   int jresult ;
83598   int result;
83599
83600   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
83601   jresult = (int)result;
83602   return jresult;
83603 }
83604
83605
83606 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
83607   int jresult ;
83608   int result;
83609
83610   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
83611   jresult = (int)result;
83612   return jresult;
83613 }
83614
83615
83616 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
83617   int jresult ;
83618   int result;
83619
83620   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
83621   jresult = (int)result;
83622   return jresult;
83623 }
83624
83625
83626 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
83627   int jresult ;
83628   int result;
83629
83630   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
83631   jresult = (int)result;
83632   return jresult;
83633 }
83634
83635
83636 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
83637   int jresult ;
83638   int result;
83639
83640   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
83641   jresult = (int)result;
83642   return jresult;
83643 }
83644
83645
83646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
83647   int jresult ;
83648   int result;
83649
83650   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
83651   jresult = (int)result;
83652   return jresult;
83653 }
83654
83655
83656 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
83657   int jresult ;
83658   int result;
83659
83660   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
83661   jresult = (int)result;
83662   return jresult;
83663 }
83664
83665
83666 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
83667   int jresult ;
83668   int result;
83669
83670   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
83671   jresult = (int)result;
83672   return jresult;
83673 }
83674
83675
83676 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
83677   int jresult ;
83678   int result;
83679
83680   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
83681   jresult = (int)result;
83682   return jresult;
83683 }
83684
83685
83686 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
83687   int jresult ;
83688   int result;
83689
83690   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
83691   jresult = (int)result;
83692   return jresult;
83693 }
83694
83695
83696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
83697   int jresult ;
83698   int result;
83699
83700   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
83701   jresult = (int)result;
83702   return jresult;
83703 }
83704
83705
83706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
83707   int jresult ;
83708   int result;
83709
83710   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
83711   jresult = (int)result;
83712   return jresult;
83713 }
83714
83715
83716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
83717   int jresult ;
83718   int result;
83719
83720   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
83721   jresult = (int)result;
83722   return jresult;
83723 }
83724
83725
83726 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
83727   int jresult ;
83728   int result;
83729
83730   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
83731   jresult = (int)result;
83732   return jresult;
83733 }
83734
83735
83736 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
83737   int jresult ;
83738   int result;
83739
83740   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
83741   jresult = (int)result;
83742   return jresult;
83743 }
83744
83745
83746 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
83747   int jresult ;
83748   int result;
83749
83750   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
83751   jresult = (int)result;
83752   return jresult;
83753 }
83754
83755
83756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
83757   void * jresult ;
83758   Dali::Toolkit::TextLabel::Property *result = 0 ;
83759
83760   {
83761     try {
83762       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
83763     } catch (std::out_of_range& e) {
83764       {
83765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83766       };
83767     } catch (std::exception& e) {
83768       {
83769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83770       };
83771     } catch (Dali::DaliException e) {
83772       {
83773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83774       };
83775     } catch (...) {
83776       {
83777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83778       };
83779     }
83780   }
83781
83782   jresult = (void *)result;
83783   return jresult;
83784 }
83785
83786
83787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
83788   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
83789
83790   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
83791   {
83792     try {
83793       delete arg1;
83794     } catch (std::out_of_range& e) {
83795       {
83796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83797       };
83798     } catch (std::exception& e) {
83799       {
83800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83801       };
83802     } catch (Dali::DaliException e) {
83803       {
83804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83805       };
83806     } catch (...) {
83807       {
83808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83809       };
83810     }
83811   }
83812
83813 }
83814
83815
83816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
83817   void * jresult ;
83818   Dali::Toolkit::TextLabel result;
83819
83820   {
83821     try {
83822       result = Dali::Toolkit::TextLabel::New();
83823     } catch (std::out_of_range& e) {
83824       {
83825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83826       };
83827     } catch (std::exception& e) {
83828       {
83829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83830       };
83831     } catch (Dali::DaliException e) {
83832       {
83833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83834       };
83835     } catch (...) {
83836       {
83837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83838       };
83839     }
83840   }
83841
83842   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
83843   return jresult;
83844 }
83845
83846
83847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
83848   void * jresult ;
83849   std::string *arg1 = 0 ;
83850   Dali::Toolkit::TextLabel result;
83851
83852   if (!jarg1) {
83853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83854     return 0;
83855   }
83856   std::string arg1_str(jarg1);
83857   arg1 = &arg1_str;
83858   {
83859     try {
83860       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
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
83882   //argout typemap for const std::string&
83883
83884   return jresult;
83885 }
83886
83887
83888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
83889   void * jresult ;
83890   Dali::Toolkit::TextLabel *result = 0 ;
83891
83892   {
83893     try {
83894       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
83895     } catch (std::out_of_range& e) {
83896       {
83897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83898       };
83899     } catch (std::exception& e) {
83900       {
83901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83902       };
83903     } catch (Dali::DaliException e) {
83904       {
83905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83906       };
83907     } catch (...) {
83908       {
83909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83910       };
83911     }
83912   }
83913
83914   jresult = (void *)result;
83915   return jresult;
83916 }
83917
83918
83919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
83920   void * jresult ;
83921   Dali::Toolkit::TextLabel *arg1 = 0 ;
83922   Dali::Toolkit::TextLabel *result = 0 ;
83923
83924   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83925   if (!arg1) {
83926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83927     return 0;
83928   }
83929   {
83930     try {
83931       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
83932     } catch (std::out_of_range& e) {
83933       {
83934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83935       };
83936     } catch (std::exception& e) {
83937       {
83938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83939       };
83940     } catch (Dali::DaliException e) {
83941       {
83942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83943       };
83944     } catch (...) {
83945       {
83946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83947       };
83948     }
83949   }
83950
83951   jresult = (void *)result;
83952   return jresult;
83953 }
83954
83955
83956 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
83957   void * jresult ;
83958   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83959   Dali::Toolkit::TextLabel *arg2 = 0 ;
83960   Dali::Toolkit::TextLabel *result = 0 ;
83961
83962   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83963   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
83964   if (!arg2) {
83965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
83966     return 0;
83967   }
83968   {
83969     try {
83970       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
83971     } catch (std::out_of_range& e) {
83972       {
83973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83974       };
83975     } catch (std::exception& e) {
83976       {
83977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83978       };
83979     } catch (Dali::DaliException e) {
83980       {
83981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83982       };
83983     } catch (...) {
83984       {
83985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83986       };
83987     }
83988   }
83989
83990   jresult = (void *)result;
83991   return jresult;
83992 }
83993
83994
83995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
83996   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
83997
83998   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
83999   {
84000     try {
84001       delete arg1;
84002     } catch (std::out_of_range& e) {
84003       {
84004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84005       };
84006     } catch (std::exception& e) {
84007       {
84008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84009       };
84010     } catch (Dali::DaliException e) {
84011       {
84012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84013       };
84014     } catch (...) {
84015       {
84016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84017       };
84018     }
84019   }
84020
84021 }
84022
84023
84024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
84025   void * jresult ;
84026   Dali::BaseHandle arg1 ;
84027   Dali::BaseHandle *argp1 ;
84028   Dali::Toolkit::TextLabel result;
84029
84030   argp1 = (Dali::BaseHandle *)jarg1;
84031   if (!argp1) {
84032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84033     return 0;
84034   }
84035   arg1 = *argp1;
84036   {
84037     try {
84038       result = Dali::Toolkit::TextLabel::DownCast(arg1);
84039     } catch (std::out_of_range& e) {
84040       {
84041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84042       };
84043     } catch (std::exception& e) {
84044       {
84045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84046       };
84047     } catch (Dali::DaliException e) {
84048       {
84049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84050       };
84051     } catch (...) {
84052       {
84053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84054       };
84055     }
84056   }
84057
84058   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
84059   return jresult;
84060 }
84061
84062
84063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
84064   void * jresult ;
84065   Dali::Toolkit::AccessibilityManager *result = 0 ;
84066
84067   {
84068     try {
84069       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
84070     } catch (std::out_of_range& e) {
84071       {
84072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84073       };
84074     } catch (std::exception& e) {
84075       {
84076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84077       };
84078     } catch (Dali::DaliException e) {
84079       {
84080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84081       };
84082     } catch (...) {
84083       {
84084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84085       };
84086     }
84087   }
84088
84089   jresult = (void *)result;
84090   return jresult;
84091 }
84092
84093
84094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
84095   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84096
84097   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84098   {
84099     try {
84100       delete arg1;
84101     } catch (std::out_of_range& e) {
84102       {
84103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84104       };
84105     } catch (std::exception& e) {
84106       {
84107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84108       };
84109     } catch (Dali::DaliException e) {
84110       {
84111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84112       };
84113     } catch (...) {
84114       {
84115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84116       };
84117     }
84118   }
84119
84120 }
84121
84122
84123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
84124   void * jresult ;
84125   Dali::Toolkit::AccessibilityManager result;
84126
84127   {
84128     try {
84129       result = Dali::Toolkit::AccessibilityManager::Get();
84130     } catch (std::out_of_range& e) {
84131       {
84132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84133       };
84134     } catch (std::exception& e) {
84135       {
84136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84137       };
84138     } catch (Dali::DaliException e) {
84139       {
84140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84141       };
84142     } catch (...) {
84143       {
84144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84145       };
84146     }
84147   }
84148
84149   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
84150   return jresult;
84151 }
84152
84153
84154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
84155   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84156   Dali::Actor arg2 ;
84157   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84158   std::string *arg4 = 0 ;
84159   Dali::Actor *argp2 ;
84160
84161   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84162   argp2 = (Dali::Actor *)jarg2;
84163   if (!argp2) {
84164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84165     return ;
84166   }
84167   arg2 = *argp2;
84168   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84169   if (!jarg4) {
84170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84171     return ;
84172   }
84173   std::string arg4_str(jarg4);
84174   arg4 = &arg4_str;
84175   {
84176     try {
84177       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
84178     } catch (std::out_of_range& e) {
84179       {
84180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84181       };
84182     } catch (std::exception& e) {
84183       {
84184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84185       };
84186     } catch (Dali::DaliException e) {
84187       {
84188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84189       };
84190     } catch (...) {
84191       {
84192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84193       };
84194     }
84195   }
84196
84197
84198   //argout typemap for const std::string&
84199
84200 }
84201
84202
84203 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
84204   char * jresult ;
84205   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84206   Dali::Actor arg2 ;
84207   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
84208   Dali::Actor *argp2 ;
84209   std::string result;
84210
84211   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84212   argp2 = (Dali::Actor *)jarg2;
84213   if (!argp2) {
84214     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84215     return 0;
84216   }
84217   arg2 = *argp2;
84218   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
84219   {
84220     try {
84221       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
84222     } catch (std::out_of_range& e) {
84223       {
84224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84225       };
84226     } catch (std::exception& e) {
84227       {
84228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84229       };
84230     } catch (Dali::DaliException e) {
84231       {
84232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84233       };
84234     } catch (...) {
84235       {
84236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84237       };
84238     }
84239   }
84240
84241   jresult = SWIG_csharp_string_callback((&result)->c_str());
84242   return jresult;
84243 }
84244
84245
84246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
84247   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84248   Dali::Actor arg2 ;
84249   unsigned int arg3 ;
84250   Dali::Actor *argp2 ;
84251
84252   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84253   argp2 = (Dali::Actor *)jarg2;
84254   if (!argp2) {
84255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84256     return ;
84257   }
84258   arg2 = *argp2;
84259   arg3 = (unsigned int)jarg3;
84260   {
84261     try {
84262       (arg1)->SetFocusOrder(arg2,arg3);
84263     } catch (std::out_of_range& e) {
84264       {
84265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84266       };
84267     } catch (std::exception& e) {
84268       {
84269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84270       };
84271     } catch (Dali::DaliException e) {
84272       {
84273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84274       };
84275     } catch (...) {
84276       {
84277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84278       };
84279     }
84280   }
84281
84282 }
84283
84284
84285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
84286   unsigned int jresult ;
84287   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84288   Dali::Actor arg2 ;
84289   Dali::Actor *argp2 ;
84290   unsigned int result;
84291
84292   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84293   argp2 = (Dali::Actor *)jarg2;
84294   if (!argp2) {
84295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84296     return 0;
84297   }
84298   arg2 = *argp2;
84299   {
84300     try {
84301       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
84302     } catch (std::out_of_range& e) {
84303       {
84304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84305       };
84306     } catch (std::exception& e) {
84307       {
84308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84309       };
84310     } catch (Dali::DaliException e) {
84311       {
84312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84313       };
84314     } catch (...) {
84315       {
84316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84317       };
84318     }
84319   }
84320
84321   jresult = result;
84322   return jresult;
84323 }
84324
84325
84326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
84327   unsigned int jresult ;
84328   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84329   unsigned int result;
84330
84331   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84332   {
84333     try {
84334       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
84335     } catch (std::out_of_range& e) {
84336       {
84337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84338       };
84339     } catch (std::exception& e) {
84340       {
84341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84342       };
84343     } catch (Dali::DaliException e) {
84344       {
84345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84346       };
84347     } catch (...) {
84348       {
84349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84350       };
84351     }
84352   }
84353
84354   jresult = result;
84355   return jresult;
84356 }
84357
84358
84359 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
84360   void * jresult ;
84361   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84362   unsigned int arg2 ;
84363   Dali::Actor result;
84364
84365   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84366   arg2 = (unsigned int)jarg2;
84367   {
84368     try {
84369       result = (arg1)->GetActorByFocusOrder(arg2);
84370     } catch (std::out_of_range& e) {
84371       {
84372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84373       };
84374     } catch (std::exception& e) {
84375       {
84376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84377       };
84378     } catch (Dali::DaliException e) {
84379       {
84380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84381       };
84382     } catch (...) {
84383       {
84384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84385       };
84386     }
84387   }
84388
84389   jresult = new Dali::Actor((const Dali::Actor &)result);
84390   return jresult;
84391 }
84392
84393
84394 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
84395   unsigned int jresult ;
84396   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84397   Dali::Actor arg2 ;
84398   Dali::Actor *argp2 ;
84399   bool result;
84400
84401   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84402   argp2 = (Dali::Actor *)jarg2;
84403   if (!argp2) {
84404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84405     return 0;
84406   }
84407   arg2 = *argp2;
84408   {
84409     try {
84410       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
84411     } catch (std::out_of_range& e) {
84412       {
84413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84414       };
84415     } catch (std::exception& e) {
84416       {
84417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84418       };
84419     } catch (Dali::DaliException e) {
84420       {
84421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84422       };
84423     } catch (...) {
84424       {
84425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84426       };
84427     }
84428   }
84429
84430   jresult = result;
84431   return jresult;
84432 }
84433
84434
84435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
84436   void * jresult ;
84437   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84438   Dali::Actor result;
84439
84440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84441   {
84442     try {
84443       result = (arg1)->GetCurrentFocusActor();
84444     } catch (std::out_of_range& e) {
84445       {
84446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84447       };
84448     } catch (std::exception& e) {
84449       {
84450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84451       };
84452     } catch (Dali::DaliException e) {
84453       {
84454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84455       };
84456     } catch (...) {
84457       {
84458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84459       };
84460     }
84461   }
84462
84463   jresult = new Dali::Actor((const Dali::Actor &)result);
84464   return jresult;
84465 }
84466
84467
84468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
84469   void * jresult ;
84470   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84471   Dali::Actor result;
84472
84473   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84474   {
84475     try {
84476       result = (arg1)->GetCurrentFocusGroup();
84477     } catch (std::out_of_range& e) {
84478       {
84479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84480       };
84481     } catch (std::exception& e) {
84482       {
84483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84484       };
84485     } catch (Dali::DaliException e) {
84486       {
84487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84488       };
84489     } catch (...) {
84490       {
84491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84492       };
84493     }
84494   }
84495
84496   jresult = new Dali::Actor((const Dali::Actor &)result);
84497   return jresult;
84498 }
84499
84500
84501 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
84502   unsigned int jresult ;
84503   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84504   unsigned int result;
84505
84506   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84507   {
84508     try {
84509       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
84510     } catch (std::out_of_range& e) {
84511       {
84512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84513       };
84514     } catch (std::exception& e) {
84515       {
84516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84517       };
84518     } catch (Dali::DaliException e) {
84519       {
84520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84521       };
84522     } catch (...) {
84523       {
84524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84525       };
84526     }
84527   }
84528
84529   jresult = result;
84530   return jresult;
84531 }
84532
84533
84534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
84535   unsigned int jresult ;
84536   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84537   bool result;
84538
84539   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84540   {
84541     try {
84542       result = (bool)(arg1)->MoveFocusForward();
84543     } catch (std::out_of_range& e) {
84544       {
84545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84546       };
84547     } catch (std::exception& e) {
84548       {
84549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84550       };
84551     } catch (Dali::DaliException e) {
84552       {
84553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84554       };
84555     } catch (...) {
84556       {
84557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84558       };
84559     }
84560   }
84561
84562   jresult = result;
84563   return jresult;
84564 }
84565
84566
84567 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
84568   unsigned int jresult ;
84569   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84570   bool result;
84571
84572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84573   {
84574     try {
84575       result = (bool)(arg1)->MoveFocusBackward();
84576     } catch (std::out_of_range& e) {
84577       {
84578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84579       };
84580     } catch (std::exception& e) {
84581       {
84582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84583       };
84584     } catch (Dali::DaliException e) {
84585       {
84586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84587       };
84588     } catch (...) {
84589       {
84590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84591       };
84592     }
84593   }
84594
84595   jresult = result;
84596   return jresult;
84597 }
84598
84599
84600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
84601   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84602
84603   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84604   {
84605     try {
84606       (arg1)->ClearFocus();
84607     } catch (std::out_of_range& e) {
84608       {
84609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84610       };
84611     } catch (std::exception& e) {
84612       {
84613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84614       };
84615     } catch (Dali::DaliException e) {
84616       {
84617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84618       };
84619     } catch (...) {
84620       {
84621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84622       };
84623     }
84624   }
84625
84626 }
84627
84628
84629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
84630   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84631
84632   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84633   {
84634     try {
84635       (arg1)->Reset();
84636     } catch (std::out_of_range& e) {
84637       {
84638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84639       };
84640     } catch (std::exception& e) {
84641       {
84642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84643       };
84644     } catch (Dali::DaliException e) {
84645       {
84646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84647       };
84648     } catch (...) {
84649       {
84650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84651       };
84652     }
84653   }
84654
84655 }
84656
84657
84658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
84659   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84660   Dali::Actor arg2 ;
84661   bool arg3 ;
84662   Dali::Actor *argp2 ;
84663
84664   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84665   argp2 = (Dali::Actor *)jarg2;
84666   if (!argp2) {
84667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84668     return ;
84669   }
84670   arg2 = *argp2;
84671   arg3 = jarg3 ? true : false;
84672   {
84673     try {
84674       (arg1)->SetFocusGroup(arg2,arg3);
84675     } catch (std::out_of_range& e) {
84676       {
84677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84678       };
84679     } catch (std::exception& e) {
84680       {
84681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84682       };
84683     } catch (Dali::DaliException e) {
84684       {
84685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84686       };
84687     } catch (...) {
84688       {
84689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84690       };
84691     }
84692   }
84693
84694 }
84695
84696
84697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
84698   unsigned int jresult ;
84699   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84700   Dali::Actor arg2 ;
84701   Dali::Actor *argp2 ;
84702   bool result;
84703
84704   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84705   argp2 = (Dali::Actor *)jarg2;
84706   if (!argp2) {
84707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84708     return 0;
84709   }
84710   arg2 = *argp2;
84711   {
84712     try {
84713       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
84714     } catch (std::out_of_range& e) {
84715       {
84716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84717       };
84718     } catch (std::exception& e) {
84719       {
84720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84721       };
84722     } catch (Dali::DaliException e) {
84723       {
84724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84725       };
84726     } catch (...) {
84727       {
84728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84729       };
84730     }
84731   }
84732
84733   jresult = result;
84734   return jresult;
84735 }
84736
84737
84738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
84739   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84740   bool arg2 ;
84741
84742   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84743   arg2 = jarg2 ? true : false;
84744   {
84745     try {
84746       (arg1)->SetGroupMode(arg2);
84747     } catch (std::out_of_range& e) {
84748       {
84749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84750       };
84751     } catch (std::exception& e) {
84752       {
84753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84754       };
84755     } catch (Dali::DaliException e) {
84756       {
84757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84758       };
84759     } catch (...) {
84760       {
84761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84762       };
84763     }
84764   }
84765
84766 }
84767
84768
84769 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
84770   unsigned int jresult ;
84771   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84772   bool result;
84773
84774   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84775   {
84776     try {
84777       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
84778     } catch (std::out_of_range& e) {
84779       {
84780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84781       };
84782     } catch (std::exception& e) {
84783       {
84784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84785       };
84786     } catch (Dali::DaliException e) {
84787       {
84788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84789       };
84790     } catch (...) {
84791       {
84792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84793       };
84794     }
84795   }
84796
84797   jresult = result;
84798   return jresult;
84799 }
84800
84801
84802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
84803   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84804   bool arg2 ;
84805
84806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84807   arg2 = jarg2 ? true : false;
84808   {
84809     try {
84810       (arg1)->SetWrapMode(arg2);
84811     } catch (std::out_of_range& e) {
84812       {
84813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84814       };
84815     } catch (std::exception& e) {
84816       {
84817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84818       };
84819     } catch (Dali::DaliException e) {
84820       {
84821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84822       };
84823     } catch (...) {
84824       {
84825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84826       };
84827     }
84828   }
84829
84830 }
84831
84832
84833 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
84834   unsigned int jresult ;
84835   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84836   bool result;
84837
84838   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84839   {
84840     try {
84841       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
84842     } catch (std::out_of_range& e) {
84843       {
84844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84845       };
84846     } catch (std::exception& e) {
84847       {
84848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84849       };
84850     } catch (Dali::DaliException e) {
84851       {
84852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84853       };
84854     } catch (...) {
84855       {
84856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84857       };
84858     }
84859   }
84860
84861   jresult = result;
84862   return jresult;
84863 }
84864
84865
84866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
84867   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84868   Dali::Actor arg2 ;
84869   Dali::Actor *argp2 ;
84870
84871   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84872   argp2 = (Dali::Actor *)jarg2;
84873   if (!argp2) {
84874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84875     return ;
84876   }
84877   arg2 = *argp2;
84878   {
84879     try {
84880       (arg1)->SetFocusIndicatorActor(arg2);
84881     } catch (std::out_of_range& e) {
84882       {
84883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84884       };
84885     } catch (std::exception& e) {
84886       {
84887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84888       };
84889     } catch (Dali::DaliException e) {
84890       {
84891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84892       };
84893     } catch (...) {
84894       {
84895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84896       };
84897     }
84898   }
84899
84900 }
84901
84902
84903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
84904   void * jresult ;
84905   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84906   Dali::Actor result;
84907
84908   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84909   {
84910     try {
84911       result = (arg1)->GetFocusIndicatorActor();
84912     } catch (std::out_of_range& e) {
84913       {
84914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84915       };
84916     } catch (std::exception& e) {
84917       {
84918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84919       };
84920     } catch (Dali::DaliException e) {
84921       {
84922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84923       };
84924     } catch (...) {
84925       {
84926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84927       };
84928     }
84929   }
84930
84931   jresult = new Dali::Actor((const Dali::Actor &)result);
84932   return jresult;
84933 }
84934
84935
84936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
84937   void * jresult ;
84938   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84939   Dali::Actor arg2 ;
84940   Dali::Actor *argp2 ;
84941   Dali::Actor result;
84942
84943   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84944   argp2 = (Dali::Actor *)jarg2;
84945   if (!argp2) {
84946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84947     return 0;
84948   }
84949   arg2 = *argp2;
84950   {
84951     try {
84952       result = (arg1)->GetFocusGroup(arg2);
84953     } catch (std::out_of_range& e) {
84954       {
84955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84956       };
84957     } catch (std::exception& e) {
84958       {
84959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84960       };
84961     } catch (Dali::DaliException e) {
84962       {
84963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84964       };
84965     } catch (...) {
84966       {
84967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84968       };
84969     }
84970   }
84971
84972   jresult = new Dali::Actor((const Dali::Actor &)result);
84973   return jresult;
84974 }
84975
84976
84977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
84978   void * jresult ;
84979   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
84980   Dali::Vector2 result;
84981
84982   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
84983   {
84984     try {
84985       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
84986     } catch (std::out_of_range& e) {
84987       {
84988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84989       };
84990     } catch (std::exception& e) {
84991       {
84992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84993       };
84994     } catch (Dali::DaliException e) {
84995       {
84996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84997       };
84998     } catch (...) {
84999       {
85000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85001       };
85002     }
85003   }
85004
85005   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
85006   return jresult;
85007 }
85008
85009
85010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
85011   void * jresult ;
85012   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85013   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
85014
85015   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85016   {
85017     try {
85018       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
85019     } catch (std::out_of_range& e) {
85020       {
85021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85022       };
85023     } catch (std::exception& e) {
85024       {
85025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85026       };
85027     } catch (Dali::DaliException e) {
85028       {
85029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85030       };
85031     } catch (...) {
85032       {
85033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85034       };
85035     }
85036   }
85037
85038   jresult = (void *)result;
85039   return jresult;
85040 }
85041
85042
85043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
85044   void * jresult ;
85045   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85046   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
85047
85048   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85049   {
85050     try {
85051       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
85052     } catch (std::out_of_range& e) {
85053       {
85054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85055       };
85056     } catch (std::exception& e) {
85057       {
85058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85059       };
85060     } catch (Dali::DaliException e) {
85061       {
85062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85063       };
85064     } catch (...) {
85065       {
85066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85067       };
85068     }
85069   }
85070
85071   jresult = (void *)result;
85072   return jresult;
85073 }
85074
85075
85076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
85077   void * jresult ;
85078   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85079   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
85080
85081   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85082   {
85083     try {
85084       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
85085     } catch (std::out_of_range& e) {
85086       {
85087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85088       };
85089     } catch (std::exception& e) {
85090       {
85091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85092       };
85093     } catch (Dali::DaliException e) {
85094       {
85095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85096       };
85097     } catch (...) {
85098       {
85099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85100       };
85101     }
85102   }
85103
85104   jresult = (void *)result;
85105   return jresult;
85106 }
85107
85108
85109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
85110   void * jresult ;
85111   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85112   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85113
85114   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85115   {
85116     try {
85117       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
85118     } catch (std::out_of_range& e) {
85119       {
85120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85121       };
85122     } catch (std::exception& e) {
85123       {
85124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85125       };
85126     } catch (Dali::DaliException e) {
85127       {
85128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85129       };
85130     } catch (...) {
85131       {
85132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85133       };
85134     }
85135   }
85136
85137   jresult = (void *)result;
85138   return jresult;
85139 }
85140
85141
85142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
85143   void * jresult ;
85144   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85145   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85146
85147   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85148   {
85149     try {
85150       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
85151     } catch (std::out_of_range& e) {
85152       {
85153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85154       };
85155     } catch (std::exception& e) {
85156       {
85157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85158       };
85159     } catch (Dali::DaliException e) {
85160       {
85161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85162       };
85163     } catch (...) {
85164       {
85165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85166       };
85167     }
85168   }
85169
85170   jresult = (void *)result;
85171   return jresult;
85172 }
85173
85174
85175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
85176   void * jresult ;
85177   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85178   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85179
85180   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85181   {
85182     try {
85183       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
85184     } catch (std::out_of_range& e) {
85185       {
85186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85187       };
85188     } catch (std::exception& e) {
85189       {
85190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85191       };
85192     } catch (Dali::DaliException e) {
85193       {
85194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85195       };
85196     } catch (...) {
85197       {
85198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85199       };
85200     }
85201   }
85202
85203   jresult = (void *)result;
85204   return jresult;
85205 }
85206
85207
85208 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
85209   void * jresult ;
85210   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85211   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85212
85213   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85214   {
85215     try {
85216       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
85217     } catch (std::out_of_range& e) {
85218       {
85219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85220       };
85221     } catch (std::exception& e) {
85222       {
85223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85224       };
85225     } catch (Dali::DaliException e) {
85226       {
85227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85228       };
85229     } catch (...) {
85230       {
85231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85232       };
85233     }
85234   }
85235
85236   jresult = (void *)result;
85237   return jresult;
85238 }
85239
85240
85241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
85242   void * jresult ;
85243   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85244   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85245
85246   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85247   {
85248     try {
85249       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
85250     } catch (std::out_of_range& e) {
85251       {
85252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85253       };
85254     } catch (std::exception& e) {
85255       {
85256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85257       };
85258     } catch (Dali::DaliException e) {
85259       {
85260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85261       };
85262     } catch (...) {
85263       {
85264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85265       };
85266     }
85267   }
85268
85269   jresult = (void *)result;
85270   return jresult;
85271 }
85272
85273
85274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
85275   void * jresult ;
85276   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85277   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85278
85279   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85280   {
85281     try {
85282       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
85283     } catch (std::out_of_range& e) {
85284       {
85285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85286       };
85287     } catch (std::exception& e) {
85288       {
85289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85290       };
85291     } catch (Dali::DaliException e) {
85292       {
85293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85294       };
85295     } catch (...) {
85296       {
85297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85298       };
85299     }
85300   }
85301
85302   jresult = (void *)result;
85303   return jresult;
85304 }
85305
85306
85307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
85308   void * jresult ;
85309   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85310   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85311
85312   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85313   {
85314     try {
85315       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
85316     } catch (std::out_of_range& e) {
85317       {
85318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85319       };
85320     } catch (std::exception& e) {
85321       {
85322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85323       };
85324     } catch (Dali::DaliException e) {
85325       {
85326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85327       };
85328     } catch (...) {
85329       {
85330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85331       };
85332     }
85333   }
85334
85335   jresult = (void *)result;
85336   return jresult;
85337 }
85338
85339
85340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
85341   void * jresult ;
85342   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85343   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85344
85345   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85346   {
85347     try {
85348       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
85349     } catch (std::out_of_range& e) {
85350       {
85351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85352       };
85353     } catch (std::exception& e) {
85354       {
85355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85356       };
85357     } catch (Dali::DaliException e) {
85358       {
85359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85360       };
85361     } catch (...) {
85362       {
85363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85364       };
85365     }
85366   }
85367
85368   jresult = (void *)result;
85369   return jresult;
85370 }
85371
85372
85373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
85374   void * jresult ;
85375   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85376   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85377
85378   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85379   {
85380     try {
85381       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
85382     } catch (std::out_of_range& e) {
85383       {
85384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85385       };
85386     } catch (std::exception& e) {
85387       {
85388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85389       };
85390     } catch (Dali::DaliException e) {
85391       {
85392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85393       };
85394     } catch (...) {
85395       {
85396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85397       };
85398     }
85399   }
85400
85401   jresult = (void *)result;
85402   return jresult;
85403 }
85404
85405
85406 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
85407   void * jresult ;
85408   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85409   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85410
85411   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85412   {
85413     try {
85414       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
85415     } catch (std::out_of_range& e) {
85416       {
85417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85418       };
85419     } catch (std::exception& e) {
85420       {
85421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85422       };
85423     } catch (Dali::DaliException e) {
85424       {
85425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85426       };
85427     } catch (...) {
85428       {
85429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85430       };
85431     }
85432   }
85433
85434   jresult = (void *)result;
85435   return jresult;
85436 }
85437
85438
85439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
85440   void * jresult ;
85441   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85442   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85443
85444   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85445   {
85446     try {
85447       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
85448     } catch (std::out_of_range& e) {
85449       {
85450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85451       };
85452     } catch (std::exception& e) {
85453       {
85454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85455       };
85456     } catch (Dali::DaliException e) {
85457       {
85458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85459       };
85460     } catch (...) {
85461       {
85462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85463       };
85464     }
85465   }
85466
85467   jresult = (void *)result;
85468   return jresult;
85469 }
85470
85471
85472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
85473   void * jresult ;
85474   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85475   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85476
85477   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85478   {
85479     try {
85480       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
85481     } catch (std::out_of_range& e) {
85482       {
85483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85484       };
85485     } catch (std::exception& e) {
85486       {
85487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85488       };
85489     } catch (Dali::DaliException e) {
85490       {
85491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85492       };
85493     } catch (...) {
85494       {
85495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85496       };
85497     }
85498   }
85499
85500   jresult = (void *)result;
85501   return jresult;
85502 }
85503
85504
85505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
85506   void * jresult ;
85507   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85508   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85509
85510   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85511   {
85512     try {
85513       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
85514     } catch (std::out_of_range& e) {
85515       {
85516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85517       };
85518     } catch (std::exception& e) {
85519       {
85520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85521       };
85522     } catch (Dali::DaliException e) {
85523       {
85524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85525       };
85526     } catch (...) {
85527       {
85528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85529       };
85530     }
85531   }
85532
85533   jresult = (void *)result;
85534   return jresult;
85535 }
85536
85537
85538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
85539   void * jresult ;
85540   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85541   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85542
85543   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85544   {
85545     try {
85546       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
85547     } catch (std::out_of_range& e) {
85548       {
85549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85550       };
85551     } catch (std::exception& e) {
85552       {
85553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85554       };
85555     } catch (Dali::DaliException e) {
85556       {
85557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85558       };
85559     } catch (...) {
85560       {
85561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85562       };
85563     }
85564   }
85565
85566   jresult = (void *)result;
85567   return jresult;
85568 }
85569
85570
85571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
85572   void * jresult ;
85573   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85574   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85575
85576   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85577   {
85578     try {
85579       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
85580     } catch (std::out_of_range& e) {
85581       {
85582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85583       };
85584     } catch (std::exception& e) {
85585       {
85586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85587       };
85588     } catch (Dali::DaliException e) {
85589       {
85590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85591       };
85592     } catch (...) {
85593       {
85594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85595       };
85596     }
85597   }
85598
85599   jresult = (void *)result;
85600   return jresult;
85601 }
85602
85603
85604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
85605   void * jresult ;
85606   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85607   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85608
85609   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85610   {
85611     try {
85612       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
85613     } catch (std::out_of_range& e) {
85614       {
85615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85616       };
85617     } catch (std::exception& e) {
85618       {
85619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85620       };
85621     } catch (Dali::DaliException e) {
85622       {
85623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85624       };
85625     } catch (...) {
85626       {
85627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85628       };
85629     }
85630   }
85631
85632   jresult = (void *)result;
85633   return jresult;
85634 }
85635
85636
85637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
85638   void * jresult ;
85639   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85640   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85641
85642   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85643   {
85644     try {
85645       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
85646     } catch (std::out_of_range& e) {
85647       {
85648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85649       };
85650     } catch (std::exception& e) {
85651       {
85652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85653       };
85654     } catch (Dali::DaliException e) {
85655       {
85656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85657       };
85658     } catch (...) {
85659       {
85660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85661       };
85662     }
85663   }
85664
85665   jresult = (void *)result;
85666   return jresult;
85667 }
85668
85669
85670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
85671   void * jresult ;
85672   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85673   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85674
85675   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85676   {
85677     try {
85678       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
85679     } catch (std::out_of_range& e) {
85680       {
85681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85682       };
85683     } catch (std::exception& e) {
85684       {
85685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85686       };
85687     } catch (Dali::DaliException e) {
85688       {
85689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85690       };
85691     } catch (...) {
85692       {
85693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85694       };
85695     }
85696   }
85697
85698   jresult = (void *)result;
85699   return jresult;
85700 }
85701
85702
85703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
85704   void * jresult ;
85705   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85706   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85707
85708   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85709   {
85710     try {
85711       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
85712     } catch (std::out_of_range& e) {
85713       {
85714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85715       };
85716     } catch (std::exception& e) {
85717       {
85718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85719       };
85720     } catch (Dali::DaliException e) {
85721       {
85722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85723       };
85724     } catch (...) {
85725       {
85726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85727       };
85728     }
85729   }
85730
85731   jresult = (void *)result;
85732   return jresult;
85733 }
85734
85735
85736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
85737   void * jresult ;
85738   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85739   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85740
85741   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85742   {
85743     try {
85744       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
85745     } catch (std::out_of_range& e) {
85746       {
85747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85748       };
85749     } catch (std::exception& e) {
85750       {
85751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85752       };
85753     } catch (Dali::DaliException e) {
85754       {
85755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85756       };
85757     } catch (...) {
85758       {
85759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85760       };
85761     }
85762   }
85763
85764   jresult = (void *)result;
85765   return jresult;
85766 }
85767
85768
85769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
85770   void * jresult ;
85771   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85772   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85773
85774   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85775   {
85776     try {
85777       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
85778     } catch (std::out_of_range& e) {
85779       {
85780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85781       };
85782     } catch (std::exception& e) {
85783       {
85784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85785       };
85786     } catch (Dali::DaliException e) {
85787       {
85788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85789       };
85790     } catch (...) {
85791       {
85792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85793       };
85794     }
85795   }
85796
85797   jresult = (void *)result;
85798   return jresult;
85799 }
85800
85801
85802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
85803   void * jresult ;
85804   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85805   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85806
85807   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85808   {
85809     try {
85810       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
85811     } catch (std::out_of_range& e) {
85812       {
85813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85814       };
85815     } catch (std::exception& e) {
85816       {
85817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85818       };
85819     } catch (Dali::DaliException e) {
85820       {
85821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85822       };
85823     } catch (...) {
85824       {
85825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85826       };
85827     }
85828   }
85829
85830   jresult = (void *)result;
85831   return jresult;
85832 }
85833
85834
85835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
85836   void * jresult ;
85837   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85838   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85839
85840   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85841   {
85842     try {
85843       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
85844     } catch (std::out_of_range& e) {
85845       {
85846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85847       };
85848     } catch (std::exception& e) {
85849       {
85850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85851       };
85852     } catch (Dali::DaliException e) {
85853       {
85854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85855       };
85856     } catch (...) {
85857       {
85858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85859       };
85860     }
85861   }
85862
85863   jresult = (void *)result;
85864   return jresult;
85865 }
85866
85867
85868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
85869   void * jresult ;
85870   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85871   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85872
85873   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85874   {
85875     try {
85876       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
85877     } catch (std::out_of_range& e) {
85878       {
85879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85880       };
85881     } catch (std::exception& e) {
85882       {
85883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85884       };
85885     } catch (Dali::DaliException e) {
85886       {
85887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85888       };
85889     } catch (...) {
85890       {
85891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85892       };
85893     }
85894   }
85895
85896   jresult = (void *)result;
85897   return jresult;
85898 }
85899
85900
85901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
85902   void * jresult ;
85903   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85904   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85905
85906   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85907   {
85908     try {
85909       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
85910     } catch (std::out_of_range& e) {
85911       {
85912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85913       };
85914     } catch (std::exception& e) {
85915       {
85916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85917       };
85918     } catch (Dali::DaliException e) {
85919       {
85920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85921       };
85922     } catch (...) {
85923       {
85924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85925       };
85926     }
85927   }
85928
85929   jresult = (void *)result;
85930   return jresult;
85931 }
85932
85933
85934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
85935   void * jresult ;
85936   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85937   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
85938
85939   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85940   {
85941     try {
85942       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
85943     } catch (std::out_of_range& e) {
85944       {
85945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85946       };
85947     } catch (std::exception& e) {
85948       {
85949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85950       };
85951     } catch (Dali::DaliException e) {
85952       {
85953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85954       };
85955     } catch (...) {
85956       {
85957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85958       };
85959     }
85960   }
85961
85962   jresult = (void *)result;
85963   return jresult;
85964 }
85965
85966
85967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
85968   void * jresult ;
85969   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
85970   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
85971
85972   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
85973   {
85974     try {
85975       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
85976     } catch (std::out_of_range& e) {
85977       {
85978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85979       };
85980     } catch (std::exception& e) {
85981       {
85982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85983       };
85984     } catch (Dali::DaliException e) {
85985       {
85986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85987       };
85988     } catch (...) {
85989       {
85990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85991       };
85992     }
85993   }
85994
85995   jresult = (void *)result;
85996   return jresult;
85997 }
85998
85999
86000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
86001   void * jresult ;
86002   Dali::Toolkit::StyleManager *result = 0 ;
86003
86004   {
86005     try {
86006       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
86007     } catch (std::out_of_range& e) {
86008       {
86009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86010       };
86011     } catch (std::exception& e) {
86012       {
86013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86014       };
86015     } catch (Dali::DaliException e) {
86016       {
86017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86018       };
86019     } catch (...) {
86020       {
86021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86022       };
86023     }
86024   }
86025
86026   jresult = (void *)result;
86027   return jresult;
86028 }
86029
86030
86031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
86032   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86033
86034   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86035   {
86036     try {
86037       delete arg1;
86038     } catch (std::out_of_range& e) {
86039       {
86040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86041       };
86042     } catch (std::exception& e) {
86043       {
86044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86045       };
86046     } catch (Dali::DaliException e) {
86047       {
86048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86049       };
86050     } catch (...) {
86051       {
86052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86053       };
86054     }
86055   }
86056
86057 }
86058
86059
86060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
86061   void * jresult ;
86062   Dali::Toolkit::StyleManager result;
86063
86064   {
86065     try {
86066       result = Dali::Toolkit::StyleManager::Get();
86067     } catch (std::out_of_range& e) {
86068       {
86069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86070       };
86071     } catch (std::exception& e) {
86072       {
86073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86074       };
86075     } catch (Dali::DaliException e) {
86076       {
86077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86078       };
86079     } catch (...) {
86080       {
86081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86082       };
86083     }
86084   }
86085
86086   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
86087   return jresult;
86088 }
86089
86090
86091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
86092   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86093   std::string *arg2 = 0 ;
86094
86095   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86096   if (!jarg2) {
86097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86098     return ;
86099   }
86100   std::string arg2_str(jarg2);
86101   arg2 = &arg2_str;
86102   {
86103     try {
86104       (arg1)->ApplyTheme((std::string const &)*arg2);
86105     } catch (std::out_of_range& e) {
86106       {
86107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86108       };
86109     } catch (std::exception& e) {
86110       {
86111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86112       };
86113     } catch (Dali::DaliException e) {
86114       {
86115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86116       };
86117     } catch (...) {
86118       {
86119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86120       };
86121     }
86122   }
86123
86124
86125   //argout typemap for const std::string&
86126
86127 }
86128
86129
86130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
86131   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86132
86133   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86134   {
86135     try {
86136       (arg1)->ApplyDefaultTheme();
86137     } catch (std::out_of_range& e) {
86138       {
86139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86140       };
86141     } catch (std::exception& e) {
86142       {
86143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86144       };
86145     } catch (Dali::DaliException e) {
86146       {
86147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86148       };
86149     } catch (...) {
86150       {
86151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86152       };
86153     }
86154   }
86155
86156 }
86157
86158
86159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86160   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86161   std::string *arg2 = 0 ;
86162   Dali::Property::Value *arg3 = 0 ;
86163
86164   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86165   if (!jarg2) {
86166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86167     return ;
86168   }
86169   std::string arg2_str(jarg2);
86170   arg2 = &arg2_str;
86171   arg3 = (Dali::Property::Value *)jarg3;
86172   if (!arg3) {
86173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
86174     return ;
86175   }
86176   {
86177     try {
86178       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
86179     } catch (std::out_of_range& e) {
86180       {
86181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86182       };
86183     } catch (std::exception& e) {
86184       {
86185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86186       };
86187     } catch (Dali::DaliException e) {
86188       {
86189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86190       };
86191     } catch (...) {
86192       {
86193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86194       };
86195     }
86196   }
86197
86198
86199   //argout typemap for const std::string&
86200
86201 }
86202
86203
86204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
86205   unsigned int jresult ;
86206   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86207   std::string *arg2 = 0 ;
86208   Dali::Property::Value *arg3 = 0 ;
86209   bool result;
86210
86211   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86212   if (!jarg2) {
86213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86214     return 0;
86215   }
86216   std::string arg2_str(jarg2);
86217   arg2 = &arg2_str;
86218   arg3 = (Dali::Property::Value *)jarg3;
86219   if (!arg3) {
86220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
86221     return 0;
86222   }
86223   {
86224     try {
86225       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
86226     } catch (std::out_of_range& e) {
86227       {
86228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86229       };
86230     } catch (std::exception& e) {
86231       {
86232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86233       };
86234     } catch (Dali::DaliException e) {
86235       {
86236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86237       };
86238     } catch (...) {
86239       {
86240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86241       };
86242     }
86243   }
86244
86245   jresult = result;
86246
86247   //argout typemap for const std::string&
86248
86249   return jresult;
86250 }
86251
86252
86253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
86254   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86255   Dali::Toolkit::Control arg2 ;
86256   std::string *arg3 = 0 ;
86257   std::string *arg4 = 0 ;
86258   Dali::Toolkit::Control *argp2 ;
86259
86260   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86261   argp2 = (Dali::Toolkit::Control *)jarg2;
86262   if (!argp2) {
86263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
86264     return ;
86265   }
86266   arg2 = *argp2;
86267   if (!jarg3) {
86268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86269     return ;
86270   }
86271   std::string arg3_str(jarg3);
86272   arg3 = &arg3_str;
86273   if (!jarg4) {
86274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86275     return ;
86276   }
86277   std::string arg4_str(jarg4);
86278   arg4 = &arg4_str;
86279   {
86280     try {
86281       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
86282     } catch (std::out_of_range& e) {
86283       {
86284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86285       };
86286     } catch (std::exception& e) {
86287       {
86288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86289       };
86290     } catch (Dali::DaliException e) {
86291       {
86292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86293       };
86294     } catch (...) {
86295       {
86296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86297       };
86298     }
86299   }
86300
86301
86302   //argout typemap for const std::string&
86303
86304
86305   //argout typemap for const std::string&
86306
86307 }
86308
86309
86310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
86311   void * jresult ;
86312   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
86313   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
86314
86315   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
86316   {
86317     try {
86318       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
86319     } catch (std::out_of_range& e) {
86320       {
86321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86322       };
86323     } catch (std::exception& e) {
86324       {
86325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86326       };
86327     } catch (Dali::DaliException e) {
86328       {
86329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86330       };
86331     } catch (...) {
86332       {
86333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86334       };
86335     }
86336   }
86337
86338   jresult = (void *)result;
86339   return jresult;
86340 }
86341
86342
86343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
86344   int jresult ;
86345   int result;
86346
86347   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
86348   jresult = (int)result;
86349   return jresult;
86350 }
86351
86352
86353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
86354   int jresult ;
86355   int result;
86356
86357   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
86358   jresult = (int)result;
86359   return jresult;
86360 }
86361
86362
86363 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
86364   int jresult ;
86365   int result;
86366
86367   result = (int)Dali::Toolkit::Slider::Property::VALUE;
86368   jresult = (int)result;
86369   return jresult;
86370 }
86371
86372
86373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
86374   int jresult ;
86375   int result;
86376
86377   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
86378   jresult = (int)result;
86379   return jresult;
86380 }
86381
86382
86383 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
86384   int jresult ;
86385   int result;
86386
86387   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
86388   jresult = (int)result;
86389   return jresult;
86390 }
86391
86392
86393 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
86394   int jresult ;
86395   int result;
86396
86397   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
86398   jresult = (int)result;
86399   return jresult;
86400 }
86401
86402
86403 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
86404   int jresult ;
86405   int result;
86406
86407   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
86408   jresult = (int)result;
86409   return jresult;
86410 }
86411
86412
86413 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
86414   int jresult ;
86415   int result;
86416
86417   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
86418   jresult = (int)result;
86419   return jresult;
86420 }
86421
86422
86423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
86424   int jresult ;
86425   int result;
86426
86427   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
86428   jresult = (int)result;
86429   return jresult;
86430 }
86431
86432
86433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
86434   int jresult ;
86435   int result;
86436
86437   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
86438   jresult = (int)result;
86439   return jresult;
86440 }
86441
86442
86443 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
86444   int jresult ;
86445   int result;
86446
86447   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
86448   jresult = (int)result;
86449   return jresult;
86450 }
86451
86452
86453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
86454   int jresult ;
86455   int result;
86456
86457   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
86458   jresult = (int)result;
86459   return jresult;
86460 }
86461
86462
86463 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
86464   int jresult ;
86465   int result;
86466
86467   result = (int)Dali::Toolkit::Slider::Property::MARKS;
86468   jresult = (int)result;
86469   return jresult;
86470 }
86471
86472
86473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
86474   int jresult ;
86475   int result;
86476
86477   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
86478   jresult = (int)result;
86479   return jresult;
86480 }
86481
86482
86483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
86484   int jresult ;
86485   int result;
86486
86487   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
86488   jresult = (int)result;
86489   return jresult;
86490 }
86491
86492
86493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
86494   void * jresult ;
86495   Dali::Toolkit::Slider::Property *result = 0 ;
86496
86497   {
86498     try {
86499       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
86500     } catch (std::out_of_range& e) {
86501       {
86502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86503       };
86504     } catch (std::exception& e) {
86505       {
86506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86507       };
86508     } catch (Dali::DaliException e) {
86509       {
86510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86511       };
86512     } catch (...) {
86513       {
86514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86515       };
86516     }
86517   }
86518
86519   jresult = (void *)result;
86520   return jresult;
86521 }
86522
86523
86524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
86525   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
86526
86527   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
86528   {
86529     try {
86530       delete arg1;
86531     } catch (std::out_of_range& e) {
86532       {
86533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86534       };
86535     } catch (std::exception& e) {
86536       {
86537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86538       };
86539     } catch (Dali::DaliException e) {
86540       {
86541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86542       };
86543     } catch (...) {
86544       {
86545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86546       };
86547     }
86548   }
86549
86550 }
86551
86552
86553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
86554   void * jresult ;
86555   Dali::Toolkit::Slider result;
86556
86557   {
86558     try {
86559       result = Dali::Toolkit::Slider::New();
86560     } catch (std::out_of_range& e) {
86561       {
86562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86563       };
86564     } catch (std::exception& e) {
86565       {
86566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86567       };
86568     } catch (Dali::DaliException e) {
86569       {
86570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86571       };
86572     } catch (...) {
86573       {
86574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86575       };
86576     }
86577   }
86578
86579   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86580   return jresult;
86581 }
86582
86583
86584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
86585   void * jresult ;
86586   Dali::Toolkit::Slider *result = 0 ;
86587
86588   {
86589     try {
86590       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
86591     } catch (std::out_of_range& e) {
86592       {
86593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86594       };
86595     } catch (std::exception& e) {
86596       {
86597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86598       };
86599     } catch (Dali::DaliException e) {
86600       {
86601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86602       };
86603     } catch (...) {
86604       {
86605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86606       };
86607     }
86608   }
86609
86610   jresult = (void *)result;
86611   return jresult;
86612 }
86613
86614
86615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
86616   void * jresult ;
86617   Dali::Toolkit::Slider *arg1 = 0 ;
86618   Dali::Toolkit::Slider *result = 0 ;
86619
86620   arg1 = (Dali::Toolkit::Slider *)jarg1;
86621   if (!arg1) {
86622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86623     return 0;
86624   }
86625   {
86626     try {
86627       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
86628     } catch (std::out_of_range& e) {
86629       {
86630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86631       };
86632     } catch (std::exception& e) {
86633       {
86634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86635       };
86636     } catch (Dali::DaliException e) {
86637       {
86638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86639       };
86640     } catch (...) {
86641       {
86642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86643       };
86644     }
86645   }
86646
86647   jresult = (void *)result;
86648   return jresult;
86649 }
86650
86651
86652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
86653   void * jresult ;
86654   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86655   Dali::Toolkit::Slider *arg2 = 0 ;
86656   Dali::Toolkit::Slider *result = 0 ;
86657
86658   arg1 = (Dali::Toolkit::Slider *)jarg1;
86659   arg2 = (Dali::Toolkit::Slider *)jarg2;
86660   if (!arg2) {
86661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
86662     return 0;
86663   }
86664   {
86665     try {
86666       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
86667     } catch (std::out_of_range& e) {
86668       {
86669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86670       };
86671     } catch (std::exception& e) {
86672       {
86673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86674       };
86675     } catch (Dali::DaliException e) {
86676       {
86677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86678       };
86679     } catch (...) {
86680       {
86681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86682       };
86683     }
86684   }
86685
86686   jresult = (void *)result;
86687   return jresult;
86688 }
86689
86690
86691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
86692   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86693
86694   arg1 = (Dali::Toolkit::Slider *)jarg1;
86695   {
86696     try {
86697       delete arg1;
86698     } catch (std::out_of_range& e) {
86699       {
86700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86701       };
86702     } catch (std::exception& e) {
86703       {
86704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86705       };
86706     } catch (Dali::DaliException e) {
86707       {
86708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86709       };
86710     } catch (...) {
86711       {
86712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86713       };
86714     }
86715   }
86716
86717 }
86718
86719
86720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
86721   void * jresult ;
86722   Dali::BaseHandle arg1 ;
86723   Dali::BaseHandle *argp1 ;
86724   Dali::Toolkit::Slider result;
86725
86726   argp1 = (Dali::BaseHandle *)jarg1;
86727   if (!argp1) {
86728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86729     return 0;
86730   }
86731   arg1 = *argp1;
86732   {
86733     try {
86734       result = Dali::Toolkit::Slider::DownCast(arg1);
86735     } catch (std::out_of_range& e) {
86736       {
86737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86738       };
86739     } catch (std::exception& e) {
86740       {
86741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86742       };
86743     } catch (Dali::DaliException e) {
86744       {
86745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86746       };
86747     } catch (...) {
86748       {
86749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86750       };
86751     }
86752   }
86753
86754   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
86755   return jresult;
86756 }
86757
86758
86759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
86760   void * jresult ;
86761   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86762   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86763
86764   arg1 = (Dali::Toolkit::Slider *)jarg1;
86765   {
86766     try {
86767       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
86768     } catch (std::out_of_range& e) {
86769       {
86770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86771       };
86772     } catch (std::exception& e) {
86773       {
86774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86775       };
86776     } catch (Dali::DaliException e) {
86777       {
86778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86779       };
86780     } catch (...) {
86781       {
86782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86783       };
86784     }
86785   }
86786
86787   jresult = (void *)result;
86788   return jresult;
86789 }
86790
86791
86792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
86793   void * jresult ;
86794   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86795   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
86796
86797   arg1 = (Dali::Toolkit::Slider *)jarg1;
86798   {
86799     try {
86800       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
86801     } catch (std::out_of_range& e) {
86802       {
86803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86804       };
86805     } catch (std::exception& e) {
86806       {
86807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86808       };
86809     } catch (Dali::DaliException e) {
86810       {
86811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86812       };
86813     } catch (...) {
86814       {
86815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86816       };
86817     }
86818   }
86819
86820   jresult = (void *)result;
86821   return jresult;
86822 }
86823
86824
86825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
86826   void * jresult ;
86827   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
86828   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
86829
86830   arg1 = (Dali::Toolkit::Slider *)jarg1;
86831   {
86832     try {
86833       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
86834     } catch (std::out_of_range& e) {
86835       {
86836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86837       };
86838     } catch (std::exception& e) {
86839       {
86840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86841       };
86842     } catch (Dali::DaliException e) {
86843       {
86844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86845       };
86846     } catch (...) {
86847       {
86848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86849       };
86850     }
86851   }
86852
86853   jresult = (void *)result;
86854   return jresult;
86855 }
86856
86857
86858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
86859   int jresult ;
86860   int result;
86861
86862   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
86863   jresult = (int)result;
86864   return jresult;
86865 }
86866
86867
86868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
86869   int jresult ;
86870   int result;
86871
86872   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
86873   jresult = (int)result;
86874   return jresult;
86875 }
86876
86877
86878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
86879   int jresult ;
86880   int result;
86881
86882   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
86883   jresult = (int)result;
86884   return jresult;
86885 }
86886
86887
86888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
86889   int jresult ;
86890   int result;
86891
86892   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
86893   jresult = (int)result;
86894   return jresult;
86895 }
86896
86897
86898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
86899   int result;
86900
86901   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
86902
86903   return result;
86904 }
86905
86906
86907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
86908   void * jresult ;
86909   Dali::Toolkit::VideoView::Property *result = 0 ;
86910
86911   {
86912     try {
86913       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
86914     } catch (std::out_of_range& e) {
86915       {
86916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86917       };
86918     } catch (std::exception& e) {
86919       {
86920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86921       };
86922     } catch (Dali::DaliException e) {
86923       {
86924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86925       };
86926     } catch (...) {
86927       {
86928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86929       };
86930     }
86931   }
86932
86933   jresult = (void *)result;
86934   return jresult;
86935 }
86936
86937
86938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
86939   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
86940
86941   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
86942   {
86943     try {
86944       delete arg1;
86945     } catch (std::out_of_range& e) {
86946       {
86947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86948       };
86949     } catch (std::exception& e) {
86950       {
86951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86952       };
86953     } catch (Dali::DaliException e) {
86954       {
86955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86956       };
86957     } catch (...) {
86958       {
86959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86960       };
86961     }
86962   }
86963
86964 }
86965
86966
86967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
86968   void * jresult ;
86969   Dali::Toolkit::VideoView result;
86970
86971   {
86972     try {
86973       result = Dali::Toolkit::VideoView::New();
86974     } catch (std::out_of_range& e) {
86975       {
86976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86977       };
86978     } catch (std::exception& e) {
86979       {
86980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86981       };
86982     } catch (Dali::DaliException e) {
86983       {
86984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86985       };
86986     } catch (...) {
86987       {
86988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86989       };
86990     }
86991   }
86992
86993   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
86994   return jresult;
86995 }
86996
86997
86998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
86999   void * jresult ;
87000   std::string *arg1 = 0 ;
87001   Dali::Toolkit::VideoView result;
87002
87003   if (!jarg1) {
87004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87005     return 0;
87006   }
87007   std::string arg1_str(jarg1);
87008   arg1 = &arg1_str;
87009   {
87010     try {
87011       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
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
87033   //argout typemap for const std::string&
87034
87035   return jresult;
87036 }
87037
87038
87039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
87040   void * jresult ;
87041   Dali::Toolkit::VideoView *result = 0 ;
87042
87043   {
87044     try {
87045       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
87046     } catch (std::out_of_range& e) {
87047       {
87048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87049       };
87050     } catch (std::exception& e) {
87051       {
87052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87053       };
87054     } catch (Dali::DaliException e) {
87055       {
87056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87057       };
87058     } catch (...) {
87059       {
87060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87061       };
87062     }
87063   }
87064
87065   jresult = (void *)result;
87066   return jresult;
87067 }
87068
87069
87070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
87071   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87072
87073   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87074   {
87075     try {
87076       delete arg1;
87077     } catch (std::out_of_range& e) {
87078       {
87079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87080       };
87081     } catch (std::exception& e) {
87082       {
87083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87084       };
87085     } catch (Dali::DaliException e) {
87086       {
87087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87088       };
87089     } catch (...) {
87090       {
87091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87092       };
87093     }
87094   }
87095
87096 }
87097
87098
87099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
87100   void * jresult ;
87101   Dali::Toolkit::VideoView *arg1 = 0 ;
87102   Dali::Toolkit::VideoView *result = 0 ;
87103
87104   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87105   if (!arg1) {
87106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87107     return 0;
87108   }
87109   {
87110     try {
87111       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
87112     } catch (std::out_of_range& e) {
87113       {
87114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87115       };
87116     } catch (std::exception& e) {
87117       {
87118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87119       };
87120     } catch (Dali::DaliException e) {
87121       {
87122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87123       };
87124     } catch (...) {
87125       {
87126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87127       };
87128     }
87129   }
87130
87131   jresult = (void *)result;
87132   return jresult;
87133 }
87134
87135
87136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
87137   void * jresult ;
87138   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87139   Dali::Toolkit::VideoView *arg2 = 0 ;
87140   Dali::Toolkit::VideoView *result = 0 ;
87141
87142   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87143   arg2 = (Dali::Toolkit::VideoView *)jarg2;
87144   if (!arg2) {
87145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
87146     return 0;
87147   }
87148   {
87149     try {
87150       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
87151     } catch (std::out_of_range& e) {
87152       {
87153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87154       };
87155     } catch (std::exception& e) {
87156       {
87157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87158       };
87159     } catch (Dali::DaliException e) {
87160       {
87161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87162       };
87163     } catch (...) {
87164       {
87165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87166       };
87167     }
87168   }
87169
87170   jresult = (void *)result;
87171   return jresult;
87172 }
87173
87174
87175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
87176   void * jresult ;
87177   Dali::BaseHandle arg1 ;
87178   Dali::BaseHandle *argp1 ;
87179   Dali::Toolkit::VideoView result;
87180
87181   argp1 = (Dali::BaseHandle *)jarg1;
87182   if (!argp1) {
87183     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87184     return 0;
87185   }
87186   arg1 = *argp1;
87187   {
87188     try {
87189       result = Dali::Toolkit::VideoView::DownCast(arg1);
87190     } catch (std::out_of_range& e) {
87191       {
87192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87193       };
87194     } catch (std::exception& e) {
87195       {
87196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87197       };
87198     } catch (Dali::DaliException e) {
87199       {
87200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87201       };
87202     } catch (...) {
87203       {
87204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87205       };
87206     }
87207   }
87208
87209   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
87210   return jresult;
87211 }
87212
87213
87214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
87215   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87216
87217   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87218   {
87219     try {
87220       (arg1)->Play();
87221     } catch (std::out_of_range& e) {
87222       {
87223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87224       };
87225     } catch (std::exception& e) {
87226       {
87227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87228       };
87229     } catch (Dali::DaliException e) {
87230       {
87231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87232       };
87233     } catch (...) {
87234       {
87235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87236       };
87237     }
87238   }
87239
87240 }
87241
87242
87243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
87244   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87245
87246   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87247   {
87248     try {
87249       (arg1)->Pause();
87250     } catch (std::out_of_range& e) {
87251       {
87252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87253       };
87254     } catch (std::exception& e) {
87255       {
87256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87257       };
87258     } catch (Dali::DaliException e) {
87259       {
87260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87261       };
87262     } catch (...) {
87263       {
87264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87265       };
87266     }
87267   }
87268
87269 }
87270
87271
87272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
87273   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87274
87275   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87276   {
87277     try {
87278       (arg1)->Stop();
87279     } catch (std::out_of_range& e) {
87280       {
87281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87282       };
87283     } catch (std::exception& e) {
87284       {
87285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87286       };
87287     } catch (Dali::DaliException e) {
87288       {
87289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87290       };
87291     } catch (...) {
87292       {
87293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87294       };
87295     }
87296   }
87297
87298 }
87299
87300
87301 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
87302   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87303   int arg2 ;
87304
87305   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87306   arg2 = (int)jarg2;
87307   {
87308     try {
87309       (arg1)->Forward(arg2);
87310     } catch (std::out_of_range& e) {
87311       {
87312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87313       };
87314     } catch (std::exception& e) {
87315       {
87316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87317       };
87318     } catch (Dali::DaliException e) {
87319       {
87320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87321       };
87322     } catch (...) {
87323       {
87324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87325       };
87326     }
87327   }
87328
87329 }
87330
87331
87332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
87333   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87334   int arg2 ;
87335
87336   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87337   arg2 = (int)jarg2;
87338   {
87339     try {
87340       (arg1)->Backward(arg2);
87341     } catch (std::out_of_range& e) {
87342       {
87343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87344       };
87345     } catch (std::exception& e) {
87346       {
87347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87348       };
87349     } catch (Dali::DaliException e) {
87350       {
87351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87352       };
87353     } catch (...) {
87354       {
87355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87356       };
87357     }
87358   }
87359
87360 }
87361
87362
87363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
87364   void * jresult ;
87365   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
87366   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
87367
87368   arg1 = (Dali::Toolkit::VideoView *)jarg1;
87369   {
87370     try {
87371       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
87372     } catch (std::out_of_range& e) {
87373       {
87374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87375       };
87376     } catch (std::exception& e) {
87377       {
87378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87379       };
87380     } catch (Dali::DaliException e) {
87381       {
87382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87383       };
87384     } catch (...) {
87385       {
87386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87387       };
87388     }
87389   }
87390
87391   jresult = (void *)result;
87392   return jresult;
87393 }
87394
87395
87396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
87397   int jresult ;
87398   int result;
87399
87400   result = (int)Dali::Toolkit::Popup::Property::TITLE;
87401   jresult = (int)result;
87402   return jresult;
87403 }
87404
87405
87406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
87407   int jresult ;
87408   int result;
87409
87410   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
87411   jresult = (int)result;
87412   return jresult;
87413 }
87414
87415
87416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
87417   int jresult ;
87418   int result;
87419
87420   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
87421   jresult = (int)result;
87422   return jresult;
87423 }
87424
87425
87426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
87427   int jresult ;
87428   int result;
87429
87430   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
87431   jresult = (int)result;
87432   return jresult;
87433 }
87434
87435
87436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
87437   int jresult ;
87438   int result;
87439
87440   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
87441   jresult = (int)result;
87442   return jresult;
87443 }
87444
87445
87446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
87447   int jresult ;
87448   int result;
87449
87450   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
87451   jresult = (int)result;
87452   return jresult;
87453 }
87454
87455
87456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
87457   int jresult ;
87458   int result;
87459
87460   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
87461   jresult = (int)result;
87462   return jresult;
87463 }
87464
87465
87466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
87467   int jresult ;
87468   int result;
87469
87470   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
87471   jresult = (int)result;
87472   return jresult;
87473 }
87474
87475
87476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
87477   int jresult ;
87478   int result;
87479
87480   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
87481   jresult = (int)result;
87482   return jresult;
87483 }
87484
87485
87486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
87487   int jresult ;
87488   int result;
87489
87490   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
87491   jresult = (int)result;
87492   return jresult;
87493 }
87494
87495
87496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
87497   int jresult ;
87498   int result;
87499
87500   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
87501   jresult = (int)result;
87502   return jresult;
87503 }
87504
87505
87506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
87507   int jresult ;
87508   int result;
87509
87510   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
87511   jresult = (int)result;
87512   return jresult;
87513 }
87514
87515
87516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
87517   int jresult ;
87518   int result;
87519
87520   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
87521   jresult = (int)result;
87522   return jresult;
87523 }
87524
87525
87526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
87527   int jresult ;
87528   int result;
87529
87530   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
87531   jresult = (int)result;
87532   return jresult;
87533 }
87534
87535
87536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
87537   int jresult ;
87538   int result;
87539
87540   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
87541   jresult = (int)result;
87542   return jresult;
87543 }
87544
87545
87546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
87547   int jresult ;
87548   int result;
87549
87550   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
87551   jresult = (int)result;
87552   return jresult;
87553 }
87554
87555
87556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
87557   int jresult ;
87558   int result;
87559
87560   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
87561   jresult = (int)result;
87562   return jresult;
87563 }
87564
87565
87566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
87567   int jresult ;
87568   int result;
87569
87570   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
87571   jresult = (int)result;
87572   return jresult;
87573 }
87574
87575
87576 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
87577   int jresult ;
87578   int result;
87579
87580   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
87581   jresult = (int)result;
87582   return jresult;
87583 }
87584
87585
87586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
87587   int jresult ;
87588   int result;
87589
87590   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
87591   jresult = (int)result;
87592   return jresult;
87593 }
87594
87595
87596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
87597   int jresult ;
87598   int result;
87599
87600   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
87601   jresult = (int)result;
87602   return jresult;
87603 }
87604
87605
87606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
87607   void * jresult ;
87608   Dali::Toolkit::Popup::Property *result = 0 ;
87609
87610   {
87611     try {
87612       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
87613     } catch (std::out_of_range& e) {
87614       {
87615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87616       };
87617     } catch (std::exception& e) {
87618       {
87619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87620       };
87621     } catch (Dali::DaliException e) {
87622       {
87623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87624       };
87625     } catch (...) {
87626       {
87627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87628       };
87629     }
87630   }
87631
87632   jresult = (void *)result;
87633   return jresult;
87634 }
87635
87636
87637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
87638   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
87639
87640   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
87641   {
87642     try {
87643       delete arg1;
87644     } catch (std::out_of_range& e) {
87645       {
87646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87647       };
87648     } catch (std::exception& e) {
87649       {
87650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87651       };
87652     } catch (Dali::DaliException e) {
87653       {
87654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87655       };
87656     } catch (...) {
87657       {
87658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87659       };
87660     }
87661   }
87662
87663 }
87664
87665
87666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
87667   void * jresult ;
87668   Dali::Toolkit::Popup *result = 0 ;
87669
87670   {
87671     try {
87672       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
87673     } catch (std::out_of_range& e) {
87674       {
87675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87676       };
87677     } catch (std::exception& e) {
87678       {
87679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87680       };
87681     } catch (Dali::DaliException e) {
87682       {
87683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87684       };
87685     } catch (...) {
87686       {
87687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87688       };
87689     }
87690   }
87691
87692   jresult = (void *)result;
87693   return jresult;
87694 }
87695
87696
87697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
87698   void * jresult ;
87699   Dali::Toolkit::Popup result;
87700
87701   {
87702     try {
87703       result = Dali::Toolkit::Popup::New();
87704     } catch (std::out_of_range& e) {
87705       {
87706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87707       };
87708     } catch (std::exception& e) {
87709       {
87710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87711       };
87712     } catch (Dali::DaliException e) {
87713       {
87714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87715       };
87716     } catch (...) {
87717       {
87718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87719       };
87720     }
87721   }
87722
87723   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87724   return jresult;
87725 }
87726
87727
87728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
87729   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87730
87731   arg1 = (Dali::Toolkit::Popup *)jarg1;
87732   {
87733     try {
87734       delete arg1;
87735     } catch (std::out_of_range& e) {
87736       {
87737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87738       };
87739     } catch (std::exception& e) {
87740       {
87741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87742       };
87743     } catch (Dali::DaliException e) {
87744       {
87745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87746       };
87747     } catch (...) {
87748       {
87749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87750       };
87751     }
87752   }
87753
87754 }
87755
87756
87757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
87758   void * jresult ;
87759   Dali::Toolkit::Popup *arg1 = 0 ;
87760   Dali::Toolkit::Popup *result = 0 ;
87761
87762   arg1 = (Dali::Toolkit::Popup *)jarg1;
87763   if (!arg1) {
87764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87765     return 0;
87766   }
87767   {
87768     try {
87769       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
87770     } catch (std::out_of_range& e) {
87771       {
87772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87773       };
87774     } catch (std::exception& e) {
87775       {
87776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87777       };
87778     } catch (Dali::DaliException e) {
87779       {
87780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87781       };
87782     } catch (...) {
87783       {
87784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87785       };
87786     }
87787   }
87788
87789   jresult = (void *)result;
87790   return jresult;
87791 }
87792
87793
87794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
87795   void * jresult ;
87796   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87797   Dali::Toolkit::Popup *arg2 = 0 ;
87798   Dali::Toolkit::Popup *result = 0 ;
87799
87800   arg1 = (Dali::Toolkit::Popup *)jarg1;
87801   arg2 = (Dali::Toolkit::Popup *)jarg2;
87802   if (!arg2) {
87803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
87804     return 0;
87805   }
87806   {
87807     try {
87808       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
87809     } catch (std::out_of_range& e) {
87810       {
87811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87812       };
87813     } catch (std::exception& e) {
87814       {
87815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87816       };
87817     } catch (Dali::DaliException e) {
87818       {
87819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87820       };
87821     } catch (...) {
87822       {
87823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87824       };
87825     }
87826   }
87827
87828   jresult = (void *)result;
87829   return jresult;
87830 }
87831
87832
87833 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
87834   void * jresult ;
87835   Dali::BaseHandle arg1 ;
87836   Dali::BaseHandle *argp1 ;
87837   Dali::Toolkit::Popup result;
87838
87839   argp1 = (Dali::BaseHandle *)jarg1;
87840   if (!argp1) {
87841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87842     return 0;
87843   }
87844   arg1 = *argp1;
87845   {
87846     try {
87847       result = Dali::Toolkit::Popup::DownCast(arg1);
87848     } catch (std::out_of_range& e) {
87849       {
87850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87851       };
87852     } catch (std::exception& e) {
87853       {
87854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87855       };
87856     } catch (Dali::DaliException e) {
87857       {
87858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87859       };
87860     } catch (...) {
87861       {
87862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87863       };
87864     }
87865   }
87866
87867   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
87868   return jresult;
87869 }
87870
87871
87872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
87873   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87874   Dali::Actor arg2 ;
87875   Dali::Actor *argp2 ;
87876
87877   arg1 = (Dali::Toolkit::Popup *)jarg1;
87878   argp2 = (Dali::Actor *)jarg2;
87879   if (!argp2) {
87880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87881     return ;
87882   }
87883   arg2 = *argp2;
87884   {
87885     try {
87886       (arg1)->SetTitle(arg2);
87887     } catch (std::out_of_range& e) {
87888       {
87889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87890       };
87891     } catch (std::exception& e) {
87892       {
87893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87894       };
87895     } catch (Dali::DaliException e) {
87896       {
87897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87898       };
87899     } catch (...) {
87900       {
87901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87902       };
87903     }
87904   }
87905
87906 }
87907
87908
87909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
87910   void * jresult ;
87911   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87912   Dali::Actor result;
87913
87914   arg1 = (Dali::Toolkit::Popup *)jarg1;
87915   {
87916     try {
87917       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
87918     } catch (std::out_of_range& e) {
87919       {
87920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87921       };
87922     } catch (std::exception& e) {
87923       {
87924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87925       };
87926     } catch (Dali::DaliException e) {
87927       {
87928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87929       };
87930     } catch (...) {
87931       {
87932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87933       };
87934     }
87935   }
87936
87937   jresult = new Dali::Actor((const Dali::Actor &)result);
87938   return jresult;
87939 }
87940
87941
87942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
87943   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87944   Dali::Actor arg2 ;
87945   Dali::Actor *argp2 ;
87946
87947   arg1 = (Dali::Toolkit::Popup *)jarg1;
87948   argp2 = (Dali::Actor *)jarg2;
87949   if (!argp2) {
87950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87951     return ;
87952   }
87953   arg2 = *argp2;
87954   {
87955     try {
87956       (arg1)->SetContent(arg2);
87957     } catch (std::out_of_range& e) {
87958       {
87959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87960       };
87961     } catch (std::exception& e) {
87962       {
87963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87964       };
87965     } catch (Dali::DaliException e) {
87966       {
87967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87968       };
87969     } catch (...) {
87970       {
87971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87972       };
87973     }
87974   }
87975
87976 }
87977
87978
87979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
87980   void * jresult ;
87981   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
87982   Dali::Actor result;
87983
87984   arg1 = (Dali::Toolkit::Popup *)jarg1;
87985   {
87986     try {
87987       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
87988     } catch (std::out_of_range& e) {
87989       {
87990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87991       };
87992     } catch (std::exception& e) {
87993       {
87994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87995       };
87996     } catch (Dali::DaliException e) {
87997       {
87998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87999       };
88000     } catch (...) {
88001       {
88002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88003       };
88004     }
88005   }
88006
88007   jresult = new Dali::Actor((const Dali::Actor &)result);
88008   return jresult;
88009 }
88010
88011
88012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
88013   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88014   Dali::Actor arg2 ;
88015   Dali::Actor *argp2 ;
88016
88017   arg1 = (Dali::Toolkit::Popup *)jarg1;
88018   argp2 = (Dali::Actor *)jarg2;
88019   if (!argp2) {
88020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88021     return ;
88022   }
88023   arg2 = *argp2;
88024   {
88025     try {
88026       (arg1)->SetFooter(arg2);
88027     } catch (std::out_of_range& e) {
88028       {
88029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88030       };
88031     } catch (std::exception& e) {
88032       {
88033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88034       };
88035     } catch (Dali::DaliException e) {
88036       {
88037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88038       };
88039     } catch (...) {
88040       {
88041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88042       };
88043     }
88044   }
88045
88046 }
88047
88048
88049 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
88050   void * jresult ;
88051   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88052   Dali::Actor result;
88053
88054   arg1 = (Dali::Toolkit::Popup *)jarg1;
88055   {
88056     try {
88057       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
88058     } catch (std::out_of_range& e) {
88059       {
88060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88061       };
88062     } catch (std::exception& e) {
88063       {
88064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88065       };
88066     } catch (Dali::DaliException e) {
88067       {
88068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88069       };
88070     } catch (...) {
88071       {
88072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88073       };
88074     }
88075   }
88076
88077   jresult = new Dali::Actor((const Dali::Actor &)result);
88078   return jresult;
88079 }
88080
88081
88082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
88083   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88084   Dali::Toolkit::Popup::DisplayState arg2 ;
88085
88086   arg1 = (Dali::Toolkit::Popup *)jarg1;
88087   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
88088   {
88089     try {
88090       (arg1)->SetDisplayState(arg2);
88091     } catch (std::out_of_range& e) {
88092       {
88093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88094       };
88095     } catch (std::exception& e) {
88096       {
88097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88098       };
88099     } catch (Dali::DaliException e) {
88100       {
88101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88102       };
88103     } catch (...) {
88104       {
88105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88106       };
88107     }
88108   }
88109
88110 }
88111
88112
88113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
88114   int jresult ;
88115   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88116   Dali::Toolkit::Popup::DisplayState result;
88117
88118   arg1 = (Dali::Toolkit::Popup *)jarg1;
88119   {
88120     try {
88121       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
88122     } catch (std::out_of_range& e) {
88123       {
88124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88125       };
88126     } catch (std::exception& e) {
88127       {
88128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88129       };
88130     } catch (Dali::DaliException e) {
88131       {
88132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88133       };
88134     } catch (...) {
88135       {
88136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88137       };
88138     }
88139   }
88140
88141   jresult = (int)result;
88142   return jresult;
88143 }
88144
88145
88146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
88147   void * jresult ;
88148   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88149   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
88150
88151   arg1 = (Dali::Toolkit::Popup *)jarg1;
88152   {
88153     try {
88154       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
88155     } catch (std::out_of_range& e) {
88156       {
88157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88158       };
88159     } catch (std::exception& e) {
88160       {
88161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88162       };
88163     } catch (Dali::DaliException e) {
88164       {
88165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88166       };
88167     } catch (...) {
88168       {
88169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88170       };
88171     }
88172   }
88173
88174   jresult = (void *)result;
88175   return jresult;
88176 }
88177
88178
88179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
88180   void * jresult ;
88181   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88182   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88183
88184   arg1 = (Dali::Toolkit::Popup *)jarg1;
88185   {
88186     try {
88187       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
88188     } catch (std::out_of_range& e) {
88189       {
88190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88191       };
88192     } catch (std::exception& e) {
88193       {
88194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88195       };
88196     } catch (Dali::DaliException e) {
88197       {
88198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88199       };
88200     } catch (...) {
88201       {
88202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88203       };
88204     }
88205   }
88206
88207   jresult = (void *)result;
88208   return jresult;
88209 }
88210
88211
88212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
88213   void * jresult ;
88214   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88215   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88216
88217   arg1 = (Dali::Toolkit::Popup *)jarg1;
88218   {
88219     try {
88220       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
88221     } catch (std::out_of_range& e) {
88222       {
88223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88224       };
88225     } catch (std::exception& e) {
88226       {
88227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88228       };
88229     } catch (Dali::DaliException e) {
88230       {
88231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88232       };
88233     } catch (...) {
88234       {
88235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88236       };
88237     }
88238   }
88239
88240   jresult = (void *)result;
88241   return jresult;
88242 }
88243
88244
88245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
88246   void * jresult ;
88247   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88248   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88249
88250   arg1 = (Dali::Toolkit::Popup *)jarg1;
88251   {
88252     try {
88253       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
88254     } catch (std::out_of_range& e) {
88255       {
88256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88257       };
88258     } catch (std::exception& e) {
88259       {
88260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88261       };
88262     } catch (Dali::DaliException e) {
88263       {
88264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88265       };
88266     } catch (...) {
88267       {
88268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88269       };
88270     }
88271   }
88272
88273   jresult = (void *)result;
88274   return jresult;
88275 }
88276
88277
88278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
88279   void * jresult ;
88280   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
88281   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
88282
88283   arg1 = (Dali::Toolkit::Popup *)jarg1;
88284   {
88285     try {
88286       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
88287     } catch (std::out_of_range& e) {
88288       {
88289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88290       };
88291     } catch (std::exception& e) {
88292       {
88293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88294       };
88295     } catch (Dali::DaliException e) {
88296       {
88297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88298       };
88299     } catch (...) {
88300       {
88301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88302       };
88303     }
88304   }
88305
88306   jresult = (void *)result;
88307   return jresult;
88308 }
88309
88310
88311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
88312   int jresult ;
88313   int result;
88314
88315   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
88316   jresult = (int)result;
88317   return jresult;
88318 }
88319
88320
88321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
88322   int jresult ;
88323   int result;
88324
88325   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
88326   jresult = (int)result;
88327   return jresult;
88328 }
88329
88330
88331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
88332   int jresult ;
88333   int result;
88334
88335   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
88336   jresult = (int)result;
88337   return jresult;
88338 }
88339
88340
88341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
88342   int jresult ;
88343   int result;
88344
88345   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
88346   jresult = (int)result;
88347   return jresult;
88348 }
88349
88350
88351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
88352   int jresult ;
88353   int result;
88354
88355   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
88356   jresult = (int)result;
88357   return jresult;
88358 }
88359
88360
88361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
88362   int jresult ;
88363   int result;
88364
88365   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
88366   jresult = (int)result;
88367   return jresult;
88368 }
88369
88370
88371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
88372   int jresult ;
88373   int result;
88374
88375   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
88376   jresult = (int)result;
88377   return jresult;
88378 }
88379
88380
88381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
88382   int jresult ;
88383   int result;
88384
88385   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
88386   jresult = (int)result;
88387   return jresult;
88388 }
88389
88390
88391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
88392   int jresult ;
88393   int result;
88394
88395   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
88396   jresult = (int)result;
88397   return jresult;
88398 }
88399
88400
88401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
88402   void * jresult ;
88403   Dali::Toolkit::ProgressBar::Property *result = 0 ;
88404
88405   {
88406     try {
88407       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
88408     } catch (std::out_of_range& e) {
88409       {
88410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88411       };
88412     } catch (std::exception& e) {
88413       {
88414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88415       };
88416     } catch (Dali::DaliException e) {
88417       {
88418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88419       };
88420     } catch (...) {
88421       {
88422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88423       };
88424     }
88425   }
88426
88427   jresult = (void *)result;
88428   return jresult;
88429 }
88430
88431
88432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
88433   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
88434
88435   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
88436   {
88437     try {
88438       delete arg1;
88439     } catch (std::out_of_range& e) {
88440       {
88441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88442       };
88443     } catch (std::exception& e) {
88444       {
88445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88446       };
88447     } catch (Dali::DaliException e) {
88448       {
88449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88450       };
88451     } catch (...) {
88452       {
88453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88454       };
88455     }
88456   }
88457
88458 }
88459
88460
88461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
88462   void * jresult ;
88463   Dali::Toolkit::ProgressBar result;
88464
88465   {
88466     try {
88467       result = Dali::Toolkit::ProgressBar::New();
88468     } catch (std::out_of_range& e) {
88469       {
88470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88471       };
88472     } catch (std::exception& e) {
88473       {
88474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88475       };
88476     } catch (Dali::DaliException e) {
88477       {
88478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88479       };
88480     } catch (...) {
88481       {
88482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88483       };
88484     }
88485   }
88486
88487   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88488   return jresult;
88489 }
88490
88491
88492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
88493   void * jresult ;
88494   Dali::Toolkit::ProgressBar *result = 0 ;
88495
88496   {
88497     try {
88498       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
88499     } catch (std::out_of_range& e) {
88500       {
88501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88502       };
88503     } catch (std::exception& e) {
88504       {
88505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88506       };
88507     } catch (Dali::DaliException e) {
88508       {
88509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88510       };
88511     } catch (...) {
88512       {
88513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88514       };
88515     }
88516   }
88517
88518   jresult = (void *)result;
88519   return jresult;
88520 }
88521
88522
88523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
88524   void * jresult ;
88525   Dali::Toolkit::ProgressBar *arg1 = 0 ;
88526   Dali::Toolkit::ProgressBar *result = 0 ;
88527
88528   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88529   if (!arg1) {
88530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88531     return 0;
88532   }
88533   {
88534     try {
88535       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
88536     } catch (std::out_of_range& e) {
88537       {
88538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88539       };
88540     } catch (std::exception& e) {
88541       {
88542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88543       };
88544     } catch (Dali::DaliException e) {
88545       {
88546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88547       };
88548     } catch (...) {
88549       {
88550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88551       };
88552     }
88553   }
88554
88555   jresult = (void *)result;
88556   return jresult;
88557 }
88558
88559
88560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
88561   void * jresult ;
88562   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88563   Dali::Toolkit::ProgressBar *arg2 = 0 ;
88564   Dali::Toolkit::ProgressBar *result = 0 ;
88565
88566   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88567   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
88568   if (!arg2) {
88569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
88570     return 0;
88571   }
88572   {
88573     try {
88574       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
88575     } catch (std::out_of_range& e) {
88576       {
88577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88578       };
88579     } catch (std::exception& e) {
88580       {
88581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88582       };
88583     } catch (Dali::DaliException e) {
88584       {
88585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88586       };
88587     } catch (...) {
88588       {
88589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88590       };
88591     }
88592   }
88593
88594   jresult = (void *)result;
88595   return jresult;
88596 }
88597
88598
88599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
88600   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88601
88602   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88603   {
88604     try {
88605       delete arg1;
88606     } catch (std::out_of_range& e) {
88607       {
88608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88609       };
88610     } catch (std::exception& e) {
88611       {
88612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88613       };
88614     } catch (Dali::DaliException e) {
88615       {
88616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88617       };
88618     } catch (...) {
88619       {
88620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88621       };
88622     }
88623   }
88624
88625 }
88626
88627
88628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
88629   void * jresult ;
88630   Dali::BaseHandle arg1 ;
88631   Dali::BaseHandle *argp1 ;
88632   Dali::Toolkit::ProgressBar result;
88633
88634   argp1 = (Dali::BaseHandle *)jarg1;
88635   if (!argp1) {
88636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88637     return 0;
88638   }
88639   arg1 = *argp1;
88640   {
88641     try {
88642       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
88643     } catch (std::out_of_range& e) {
88644       {
88645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88646       };
88647     } catch (std::exception& e) {
88648       {
88649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88650       };
88651     } catch (Dali::DaliException e) {
88652       {
88653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88654       };
88655     } catch (...) {
88656       {
88657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88658       };
88659     }
88660   }
88661
88662   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
88663   return jresult;
88664 }
88665
88666
88667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
88668   void * jresult ;
88669   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
88670   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
88671
88672   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
88673   {
88674     try {
88675       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
88676     } catch (std::out_of_range& e) {
88677       {
88678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88679       };
88680     } catch (std::exception& e) {
88681       {
88682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88683       };
88684     } catch (Dali::DaliException e) {
88685       {
88686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88687       };
88688     } catch (...) {
88689       {
88690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88691       };
88692     }
88693   }
88694
88695   jresult = (void *)result;
88696   return jresult;
88697 }
88698
88699
88700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
88701   void * jresult ;
88702   Dali::Toolkit::GaussianBlurView *result = 0 ;
88703
88704   {
88705     try {
88706       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
88707     } catch (std::out_of_range& e) {
88708       {
88709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88710       };
88711     } catch (std::exception& e) {
88712       {
88713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88714       };
88715     } catch (Dali::DaliException e) {
88716       {
88717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88718       };
88719     } catch (...) {
88720       {
88721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88722       };
88723     }
88724   }
88725
88726   jresult = (void *)result;
88727   return jresult;
88728 }
88729
88730
88731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
88732   void * jresult ;
88733   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
88734   Dali::Toolkit::GaussianBlurView *result = 0 ;
88735
88736   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88737   if (!arg1) {
88738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88739     return 0;
88740   }
88741   {
88742     try {
88743       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
88744     } catch (std::out_of_range& e) {
88745       {
88746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88747       };
88748     } catch (std::exception& e) {
88749       {
88750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88751       };
88752     } catch (Dali::DaliException e) {
88753       {
88754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88755       };
88756     } catch (...) {
88757       {
88758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88759       };
88760     }
88761   }
88762
88763   jresult = (void *)result;
88764   return jresult;
88765 }
88766
88767
88768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
88769   void * jresult ;
88770   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88771   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
88772   Dali::Toolkit::GaussianBlurView *result = 0 ;
88773
88774   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88775   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
88776   if (!arg2) {
88777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
88778     return 0;
88779   }
88780   {
88781     try {
88782       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
88783     } catch (std::out_of_range& e) {
88784       {
88785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88786       };
88787     } catch (std::exception& e) {
88788       {
88789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88790       };
88791     } catch (Dali::DaliException e) {
88792       {
88793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88794       };
88795     } catch (...) {
88796       {
88797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88798       };
88799     }
88800   }
88801
88802   jresult = (void *)result;
88803   return jresult;
88804 }
88805
88806
88807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
88808   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88809
88810   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88811   {
88812     try {
88813       delete arg1;
88814     } catch (std::out_of_range& e) {
88815       {
88816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88817       };
88818     } catch (std::exception& e) {
88819       {
88820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88821       };
88822     } catch (Dali::DaliException e) {
88823       {
88824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88825       };
88826     } catch (...) {
88827       {
88828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88829       };
88830     }
88831   }
88832
88833 }
88834
88835
88836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
88837   void * jresult ;
88838   Dali::BaseHandle arg1 ;
88839   Dali::BaseHandle *argp1 ;
88840   Dali::Toolkit::GaussianBlurView result;
88841
88842   argp1 = (Dali::BaseHandle *)jarg1;
88843   if (!argp1) {
88844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88845     return 0;
88846   }
88847   arg1 = *argp1;
88848   {
88849     try {
88850       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
88851     } catch (std::out_of_range& e) {
88852       {
88853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88854       };
88855     } catch (std::exception& e) {
88856       {
88857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88858       };
88859     } catch (Dali::DaliException e) {
88860       {
88861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88862       };
88863     } catch (...) {
88864       {
88865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88866       };
88867     }
88868   }
88869
88870   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88871   return jresult;
88872 }
88873
88874
88875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
88876   void * jresult ;
88877   Dali::Toolkit::GaussianBlurView result;
88878
88879   {
88880     try {
88881       result = Dali::Toolkit::GaussianBlurView::New();
88882     } catch (std::out_of_range& e) {
88883       {
88884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88885       };
88886     } catch (std::exception& e) {
88887       {
88888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88889       };
88890     } catch (Dali::DaliException e) {
88891       {
88892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88893       };
88894     } catch (...) {
88895       {
88896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88897       };
88898     }
88899   }
88900
88901   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88902   return jresult;
88903 }
88904
88905
88906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
88907   void * jresult ;
88908   unsigned int arg1 ;
88909   float arg2 ;
88910   Dali::Pixel::Format arg3 ;
88911   float arg4 ;
88912   float arg5 ;
88913   bool arg6 ;
88914   Dali::Toolkit::GaussianBlurView result;
88915
88916   arg1 = (unsigned int)jarg1;
88917   arg2 = (float)jarg2;
88918   arg3 = (Dali::Pixel::Format)jarg3;
88919   arg4 = (float)jarg4;
88920   arg5 = (float)jarg5;
88921   arg6 = jarg6 ? true : false;
88922   {
88923     try {
88924       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
88925     } catch (std::out_of_range& e) {
88926       {
88927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88928       };
88929     } catch (std::exception& e) {
88930       {
88931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88932       };
88933     } catch (Dali::DaliException e) {
88934       {
88935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88936       };
88937     } catch (...) {
88938       {
88939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88940       };
88941     }
88942   }
88943
88944   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88945   return jresult;
88946 }
88947
88948
88949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
88950   void * jresult ;
88951   unsigned int arg1 ;
88952   float arg2 ;
88953   Dali::Pixel::Format arg3 ;
88954   float arg4 ;
88955   float arg5 ;
88956   Dali::Toolkit::GaussianBlurView result;
88957
88958   arg1 = (unsigned int)jarg1;
88959   arg2 = (float)jarg2;
88960   arg3 = (Dali::Pixel::Format)jarg3;
88961   arg4 = (float)jarg4;
88962   arg5 = (float)jarg5;
88963   {
88964     try {
88965       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
88966     } catch (std::out_of_range& e) {
88967       {
88968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88969       };
88970     } catch (std::exception& e) {
88971       {
88972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88973       };
88974     } catch (Dali::DaliException e) {
88975       {
88976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88977       };
88978     } catch (...) {
88979       {
88980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88981       };
88982     }
88983   }
88984
88985   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
88986   return jresult;
88987 }
88988
88989
88990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
88991   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
88992   Dali::Actor arg2 ;
88993   Dali::Actor *argp2 ;
88994
88995   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
88996   argp2 = (Dali::Actor *)jarg2;
88997   if (!argp2) {
88998     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88999     return ;
89000   }
89001   arg2 = *argp2;
89002   {
89003     try {
89004       (arg1)->Add(arg2);
89005     } catch (std::out_of_range& e) {
89006       {
89007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89008       };
89009     } catch (std::exception& e) {
89010       {
89011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89012       };
89013     } catch (Dali::DaliException e) {
89014       {
89015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89016       };
89017     } catch (...) {
89018       {
89019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89020       };
89021     }
89022   }
89023
89024 }
89025
89026
89027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
89028   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89029   Dali::Actor arg2 ;
89030   Dali::Actor *argp2 ;
89031
89032   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89033   argp2 = (Dali::Actor *)jarg2;
89034   if (!argp2) {
89035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89036     return ;
89037   }
89038   arg2 = *argp2;
89039   {
89040     try {
89041       (arg1)->Remove(arg2);
89042     } catch (std::out_of_range& e) {
89043       {
89044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89045       };
89046     } catch (std::exception& e) {
89047       {
89048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89049       };
89050     } catch (Dali::DaliException e) {
89051       {
89052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89053       };
89054     } catch (...) {
89055       {
89056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89057       };
89058     }
89059   }
89060
89061 }
89062
89063
89064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
89065   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89066
89067   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89068   {
89069     try {
89070       (arg1)->Activate();
89071     } catch (std::out_of_range& e) {
89072       {
89073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89074       };
89075     } catch (std::exception& e) {
89076       {
89077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89078       };
89079     } catch (Dali::DaliException e) {
89080       {
89081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89082       };
89083     } catch (...) {
89084       {
89085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89086       };
89087     }
89088   }
89089
89090 }
89091
89092
89093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
89094   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89095
89096   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89097   {
89098     try {
89099       (arg1)->ActivateOnce();
89100     } catch (std::out_of_range& e) {
89101       {
89102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89103       };
89104     } catch (std::exception& e) {
89105       {
89106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89107       };
89108     } catch (Dali::DaliException e) {
89109       {
89110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89111       };
89112     } catch (...) {
89113       {
89114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89115       };
89116     }
89117   }
89118
89119 }
89120
89121
89122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
89123   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89124
89125   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89126   {
89127     try {
89128       (arg1)->Deactivate();
89129     } catch (std::out_of_range& e) {
89130       {
89131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89132       };
89133     } catch (std::exception& e) {
89134       {
89135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89136       };
89137     } catch (Dali::DaliException e) {
89138       {
89139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89140       };
89141     } catch (...) {
89142       {
89143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89144       };
89145     }
89146   }
89147
89148 }
89149
89150
89151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
89152   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89153   Dali::Image arg2 ;
89154   Dali::FrameBufferImage arg3 ;
89155   Dali::Image *argp2 ;
89156   Dali::FrameBufferImage *argp3 ;
89157
89158   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89159   argp2 = (Dali::Image *)jarg2;
89160   if (!argp2) {
89161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
89162     return ;
89163   }
89164   arg2 = *argp2;
89165   argp3 = (Dali::FrameBufferImage *)jarg3;
89166   if (!argp3) {
89167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
89168     return ;
89169   }
89170   arg3 = *argp3;
89171   {
89172     try {
89173       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
89174     } catch (std::out_of_range& e) {
89175       {
89176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89177       };
89178     } catch (std::exception& e) {
89179       {
89180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89181       };
89182     } catch (Dali::DaliException e) {
89183       {
89184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89185       };
89186     } catch (...) {
89187       {
89188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89189       };
89190     }
89191   }
89192
89193 }
89194
89195
89196 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
89197   int jresult ;
89198   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89199   Dali::Property::Index result;
89200
89201   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89202   {
89203     try {
89204       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
89205     } catch (std::out_of_range& e) {
89206       {
89207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89208       };
89209     } catch (std::exception& e) {
89210       {
89211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89212       };
89213     } catch (Dali::DaliException e) {
89214       {
89215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89216       };
89217     } catch (...) {
89218       {
89219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89220       };
89221     }
89222   }
89223
89224   jresult = result;
89225   return jresult;
89226 }
89227
89228
89229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
89230   void * jresult ;
89231   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89232   Dali::FrameBufferImage result;
89233
89234   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89235   {
89236     try {
89237       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
89238     } catch (std::out_of_range& e) {
89239       {
89240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89241       };
89242     } catch (std::exception& e) {
89243       {
89244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89245       };
89246     } catch (Dali::DaliException e) {
89247       {
89248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89249       };
89250     } catch (...) {
89251       {
89252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89253       };
89254     }
89255   }
89256
89257   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
89258   return jresult;
89259 }
89260
89261
89262 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
89263   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89264   Dali::Vector4 *arg2 = 0 ;
89265
89266   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89267   arg2 = (Dali::Vector4 *)jarg2;
89268   if (!arg2) {
89269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
89270     return ;
89271   }
89272   {
89273     try {
89274       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
89275     } catch (std::out_of_range& e) {
89276       {
89277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89278       };
89279     } catch (std::exception& e) {
89280       {
89281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89282       };
89283     } catch (Dali::DaliException e) {
89284       {
89285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89286       };
89287     } catch (...) {
89288       {
89289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89290       };
89291     }
89292   }
89293
89294 }
89295
89296
89297 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
89298   void * jresult ;
89299   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89300   Dali::Vector4 result;
89301
89302   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89303   {
89304     try {
89305       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
89306     } catch (std::out_of_range& e) {
89307       {
89308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89309       };
89310     } catch (std::exception& e) {
89311       {
89312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89313       };
89314     } catch (Dali::DaliException e) {
89315       {
89316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89317       };
89318     } catch (...) {
89319       {
89320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89321       };
89322     }
89323   }
89324
89325   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
89326   return jresult;
89327 }
89328
89329
89330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
89331   void * jresult ;
89332   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
89333   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
89334
89335   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
89336   {
89337     try {
89338       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
89339     } catch (std::out_of_range& e) {
89340       {
89341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89342       };
89343     } catch (std::exception& e) {
89344       {
89345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89346       };
89347     } catch (Dali::DaliException e) {
89348       {
89349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89350       };
89351     } catch (...) {
89352       {
89353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89354       };
89355     }
89356   }
89357
89358   jresult = (void *)result;
89359   return jresult;
89360 }
89361
89362
89363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
89364   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89365
89366   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89367   {
89368     try {
89369       delete arg1;
89370     } catch (std::out_of_range& e) {
89371       {
89372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89373       };
89374     } catch (std::exception& e) {
89375       {
89376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89377       };
89378     } catch (Dali::DaliException e) {
89379       {
89380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89381       };
89382     } catch (...) {
89383       {
89384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89385       };
89386     }
89387   }
89388
89389 }
89390
89391
89392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
89393   unsigned int jresult ;
89394   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89395   unsigned int result;
89396
89397   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89398   {
89399     try {
89400       result = (unsigned int)(arg1)->GetNumberOfPages();
89401     } catch (std::out_of_range& e) {
89402       {
89403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89404       };
89405     } catch (std::exception& e) {
89406       {
89407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89408       };
89409     } catch (Dali::DaliException e) {
89410       {
89411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89412       };
89413     } catch (...) {
89414       {
89415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89416       };
89417     }
89418   }
89419
89420   jresult = result;
89421   return jresult;
89422 }
89423
89424
89425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
89426   void * jresult ;
89427   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
89428   unsigned int arg2 ;
89429   Dali::Texture result;
89430
89431   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
89432   arg2 = (unsigned int)jarg2;
89433   {
89434     try {
89435       result = (arg1)->NewPage(arg2);
89436     } catch (std::out_of_range& e) {
89437       {
89438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89439       };
89440     } catch (std::exception& e) {
89441       {
89442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89443       };
89444     } catch (Dali::DaliException e) {
89445       {
89446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89447       };
89448     } catch (...) {
89449       {
89450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89451       };
89452     }
89453   }
89454
89455   jresult = new Dali::Texture((const Dali::Texture &)result);
89456   return jresult;
89457 }
89458
89459
89460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_PAGE_SIZE_get() {
89461   int jresult ;
89462   int result;
89463
89464   result = (int)Dali::Toolkit::PageTurnView::Property::PAGE_SIZE;
89465   jresult = (int)result;
89466   return jresult;
89467 }
89468
89469
89470 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
89471   int jresult ;
89472   int result;
89473
89474   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
89475   jresult = (int)result;
89476   return jresult;
89477 }
89478
89479
89480 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
89481   int jresult ;
89482   int result;
89483
89484   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
89485   jresult = (int)result;
89486   return jresult;
89487 }
89488
89489
89490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
89491   void * jresult ;
89492   Dali::Toolkit::PageTurnView::Property *result = 0 ;
89493
89494   {
89495     try {
89496       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
89497     } catch (std::out_of_range& e) {
89498       {
89499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89500       };
89501     } catch (std::exception& e) {
89502       {
89503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89504       };
89505     } catch (Dali::DaliException e) {
89506       {
89507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89508       };
89509     } catch (...) {
89510       {
89511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89512       };
89513     }
89514   }
89515
89516   jresult = (void *)result;
89517   return jresult;
89518 }
89519
89520
89521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
89522   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
89523
89524   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
89525   {
89526     try {
89527       delete arg1;
89528     } catch (std::out_of_range& e) {
89529       {
89530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89531       };
89532     } catch (std::exception& e) {
89533       {
89534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89535       };
89536     } catch (Dali::DaliException e) {
89537       {
89538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89539       };
89540     } catch (...) {
89541       {
89542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89543       };
89544     }
89545   }
89546
89547 }
89548
89549
89550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
89551   void * jresult ;
89552   Dali::Toolkit::PageTurnView *result = 0 ;
89553
89554   {
89555     try {
89556       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
89557     } catch (std::out_of_range& e) {
89558       {
89559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89560       };
89561     } catch (std::exception& e) {
89562       {
89563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89564       };
89565     } catch (Dali::DaliException e) {
89566       {
89567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89568       };
89569     } catch (...) {
89570       {
89571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89572       };
89573     }
89574   }
89575
89576   jresult = (void *)result;
89577   return jresult;
89578 }
89579
89580
89581 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
89582   void * jresult ;
89583   Dali::Toolkit::PageTurnView *arg1 = 0 ;
89584   Dali::Toolkit::PageTurnView *result = 0 ;
89585
89586   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89587   if (!arg1) {
89588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89589     return 0;
89590   }
89591   {
89592     try {
89593       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
89594     } catch (std::out_of_range& e) {
89595       {
89596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89597       };
89598     } catch (std::exception& e) {
89599       {
89600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89601       };
89602     } catch (Dali::DaliException e) {
89603       {
89604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89605       };
89606     } catch (...) {
89607       {
89608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89609       };
89610     }
89611   }
89612
89613   jresult = (void *)result;
89614   return jresult;
89615 }
89616
89617
89618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
89619   void * jresult ;
89620   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89621   Dali::Toolkit::PageTurnView *arg2 = 0 ;
89622   Dali::Toolkit::PageTurnView *result = 0 ;
89623
89624   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89625   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
89626   if (!arg2) {
89627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
89628     return 0;
89629   }
89630   {
89631     try {
89632       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
89633     } catch (std::out_of_range& e) {
89634       {
89635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89636       };
89637     } catch (std::exception& e) {
89638       {
89639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89640       };
89641     } catch (Dali::DaliException e) {
89642       {
89643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89644       };
89645     } catch (...) {
89646       {
89647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89648       };
89649     }
89650   }
89651
89652   jresult = (void *)result;
89653   return jresult;
89654 }
89655
89656
89657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
89658   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89659
89660   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89661   {
89662     try {
89663       delete arg1;
89664     } catch (std::out_of_range& e) {
89665       {
89666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89667       };
89668     } catch (std::exception& e) {
89669       {
89670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89671       };
89672     } catch (Dali::DaliException e) {
89673       {
89674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89675       };
89676     } catch (...) {
89677       {
89678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89679       };
89680     }
89681   }
89682
89683 }
89684
89685
89686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
89687   void * jresult ;
89688   Dali::BaseHandle arg1 ;
89689   Dali::BaseHandle *argp1 ;
89690   Dali::Toolkit::PageTurnView result;
89691
89692   argp1 = (Dali::BaseHandle *)jarg1;
89693   if (!argp1) {
89694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89695     return 0;
89696   }
89697   arg1 = *argp1;
89698   {
89699     try {
89700       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
89701     } catch (std::out_of_range& e) {
89702       {
89703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89704       };
89705     } catch (std::exception& e) {
89706       {
89707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89708       };
89709     } catch (Dali::DaliException e) {
89710       {
89711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89712       };
89713     } catch (...) {
89714       {
89715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89716       };
89717     }
89718   }
89719
89720   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
89721   return jresult;
89722 }
89723
89724
89725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
89726   void * jresult ;
89727   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89728   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89729
89730   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89731   {
89732     try {
89733       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
89734     } catch (std::out_of_range& e) {
89735       {
89736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89737       };
89738     } catch (std::exception& e) {
89739       {
89740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89741       };
89742     } catch (Dali::DaliException e) {
89743       {
89744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89745       };
89746     } catch (...) {
89747       {
89748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89749       };
89750     }
89751   }
89752
89753   jresult = (void *)result;
89754   return jresult;
89755 }
89756
89757
89758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
89759   void * jresult ;
89760   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89761   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
89762
89763   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89764   {
89765     try {
89766       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
89767     } catch (std::out_of_range& e) {
89768       {
89769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89770       };
89771     } catch (std::exception& e) {
89772       {
89773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89774       };
89775     } catch (Dali::DaliException e) {
89776       {
89777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89778       };
89779     } catch (...) {
89780       {
89781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89782       };
89783     }
89784   }
89785
89786   jresult = (void *)result;
89787   return jresult;
89788 }
89789
89790
89791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
89792   void * jresult ;
89793   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89794   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89795
89796   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89797   {
89798     try {
89799       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
89800     } catch (std::out_of_range& e) {
89801       {
89802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89803       };
89804     } catch (std::exception& e) {
89805       {
89806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89807       };
89808     } catch (Dali::DaliException e) {
89809       {
89810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89811       };
89812     } catch (...) {
89813       {
89814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89815       };
89816     }
89817   }
89818
89819   jresult = (void *)result;
89820   return jresult;
89821 }
89822
89823
89824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
89825   void * jresult ;
89826   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
89827   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
89828
89829   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
89830   {
89831     try {
89832       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
89833     } catch (std::out_of_range& e) {
89834       {
89835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89836       };
89837     } catch (std::exception& e) {
89838       {
89839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89840       };
89841     } catch (Dali::DaliException e) {
89842       {
89843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89844       };
89845     } catch (...) {
89846       {
89847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89848       };
89849     }
89850   }
89851
89852   jresult = (void *)result;
89853   return jresult;
89854 }
89855
89856
89857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
89858   void * jresult ;
89859   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89860
89861   {
89862     try {
89863       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
89864     } catch (std::out_of_range& e) {
89865       {
89866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89867       };
89868     } catch (std::exception& e) {
89869       {
89870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89871       };
89872     } catch (Dali::DaliException e) {
89873       {
89874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89875       };
89876     } catch (...) {
89877       {
89878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89879       };
89880     }
89881   }
89882
89883   jresult = (void *)result;
89884   return jresult;
89885 }
89886
89887
89888 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
89889   void * jresult ;
89890   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
89891   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89892
89893   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89894   if (!arg1) {
89895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89896     return 0;
89897   }
89898   {
89899     try {
89900       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
89901     } catch (std::out_of_range& e) {
89902       {
89903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89904       };
89905     } catch (std::exception& e) {
89906       {
89907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89908       };
89909     } catch (Dali::DaliException e) {
89910       {
89911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89912       };
89913     } catch (...) {
89914       {
89915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89916       };
89917     }
89918   }
89919
89920   jresult = (void *)result;
89921   return jresult;
89922 }
89923
89924
89925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
89926   void * jresult ;
89927   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89928   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
89929   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
89930
89931   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89932   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
89933   if (!arg2) {
89934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
89935     return 0;
89936   }
89937   {
89938     try {
89939       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
89940     } catch (std::out_of_range& e) {
89941       {
89942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89943       };
89944     } catch (std::exception& e) {
89945       {
89946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89947       };
89948     } catch (Dali::DaliException e) {
89949       {
89950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89951       };
89952     } catch (...) {
89953       {
89954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89955       };
89956     }
89957   }
89958
89959   jresult = (void *)result;
89960   return jresult;
89961 }
89962
89963
89964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
89965   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
89966
89967   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
89968   {
89969     try {
89970       delete arg1;
89971     } catch (std::out_of_range& e) {
89972       {
89973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89974       };
89975     } catch (std::exception& e) {
89976       {
89977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89978       };
89979     } catch (Dali::DaliException e) {
89980       {
89981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89982       };
89983     } catch (...) {
89984       {
89985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89986       };
89987     }
89988   }
89989
89990 }
89991
89992
89993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
89994   void * jresult ;
89995   Dali::Toolkit::PageFactory *arg1 = 0 ;
89996   Dali::Vector2 *arg2 = 0 ;
89997   Dali::Toolkit::PageTurnLandscapeView result;
89998
89999   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90000   if (!arg1) {
90001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90002     return 0;
90003   }
90004   arg2 = (Dali::Vector2 *)jarg2;
90005   if (!arg2) {
90006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90007     return 0;
90008   }
90009   {
90010     try {
90011       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
90012     } catch (std::out_of_range& e) {
90013       {
90014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90015       };
90016     } catch (std::exception& e) {
90017       {
90018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90019       };
90020     } catch (Dali::DaliException e) {
90021       {
90022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90023       };
90024     } catch (...) {
90025       {
90026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90027       };
90028     }
90029   }
90030
90031   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90032   return jresult;
90033 }
90034
90035
90036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
90037   void * jresult ;
90038   Dali::BaseHandle arg1 ;
90039   Dali::BaseHandle *argp1 ;
90040   Dali::Toolkit::PageTurnLandscapeView result;
90041
90042   argp1 = (Dali::BaseHandle *)jarg1;
90043   if (!argp1) {
90044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90045     return 0;
90046   }
90047   arg1 = *argp1;
90048   {
90049     try {
90050       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
90051     } catch (std::out_of_range& e) {
90052       {
90053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90054       };
90055     } catch (std::exception& e) {
90056       {
90057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90058       };
90059     } catch (Dali::DaliException e) {
90060       {
90061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90062       };
90063     } catch (...) {
90064       {
90065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90066       };
90067     }
90068   }
90069
90070   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
90071   return jresult;
90072 }
90073
90074
90075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
90076   void * jresult ;
90077   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90078
90079   {
90080     try {
90081       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
90082     } catch (std::out_of_range& e) {
90083       {
90084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90085       };
90086     } catch (std::exception& e) {
90087       {
90088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90089       };
90090     } catch (Dali::DaliException e) {
90091       {
90092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90093       };
90094     } catch (...) {
90095       {
90096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90097       };
90098     }
90099   }
90100
90101   jresult = (void *)result;
90102   return jresult;
90103 }
90104
90105
90106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
90107   void * jresult ;
90108   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
90109   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90110
90111   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90112   if (!arg1) {
90113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90114     return 0;
90115   }
90116   {
90117     try {
90118       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
90119     } catch (std::out_of_range& e) {
90120       {
90121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90122       };
90123     } catch (std::exception& e) {
90124       {
90125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90126       };
90127     } catch (Dali::DaliException e) {
90128       {
90129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90130       };
90131     } catch (...) {
90132       {
90133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90134       };
90135     }
90136   }
90137
90138   jresult = (void *)result;
90139   return jresult;
90140 }
90141
90142
90143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
90144   void * jresult ;
90145   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90146   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
90147   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
90148
90149   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90150   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
90151   if (!arg2) {
90152     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
90153     return 0;
90154   }
90155   {
90156     try {
90157       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
90158     } catch (std::out_of_range& e) {
90159       {
90160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90161       };
90162     } catch (std::exception& e) {
90163       {
90164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90165       };
90166     } catch (Dali::DaliException e) {
90167       {
90168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90169       };
90170     } catch (...) {
90171       {
90172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90173       };
90174     }
90175   }
90176
90177   jresult = (void *)result;
90178   return jresult;
90179 }
90180
90181
90182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
90183   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
90184
90185   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
90186   {
90187     try {
90188       delete arg1;
90189     } catch (std::out_of_range& e) {
90190       {
90191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90192       };
90193     } catch (std::exception& e) {
90194       {
90195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90196       };
90197     } catch (Dali::DaliException e) {
90198       {
90199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90200       };
90201     } catch (...) {
90202       {
90203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90204       };
90205     }
90206   }
90207
90208 }
90209
90210
90211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
90212   void * jresult ;
90213   Dali::Toolkit::PageFactory *arg1 = 0 ;
90214   Dali::Vector2 *arg2 = 0 ;
90215   Dali::Toolkit::PageTurnPortraitView result;
90216
90217   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
90218   if (!arg1) {
90219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
90220     return 0;
90221   }
90222   arg2 = (Dali::Vector2 *)jarg2;
90223   if (!arg2) {
90224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
90225     return 0;
90226   }
90227   {
90228     try {
90229       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
90230     } catch (std::out_of_range& e) {
90231       {
90232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90233       };
90234     } catch (std::exception& e) {
90235       {
90236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90237       };
90238     } catch (Dali::DaliException e) {
90239       {
90240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90241       };
90242     } catch (...) {
90243       {
90244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90245       };
90246     }
90247   }
90248
90249   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90250   return jresult;
90251 }
90252
90253
90254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
90255   void * jresult ;
90256   Dali::BaseHandle arg1 ;
90257   Dali::BaseHandle *argp1 ;
90258   Dali::Toolkit::PageTurnPortraitView result;
90259
90260   argp1 = (Dali::BaseHandle *)jarg1;
90261   if (!argp1) {
90262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90263     return 0;
90264   }
90265   arg1 = *argp1;
90266   {
90267     try {
90268       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
90269     } catch (std::out_of_range& e) {
90270       {
90271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90272       };
90273     } catch (std::exception& e) {
90274       {
90275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90276       };
90277     } catch (Dali::DaliException e) {
90278       {
90279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90280       };
90281     } catch (...) {
90282       {
90283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90284       };
90285     }
90286   }
90287
90288   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
90289   return jresult;
90290 }
90291
90292
90293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
90294   int jresult ;
90295   int result;
90296
90297   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
90298   jresult = (int)result;
90299   return jresult;
90300 }
90301
90302
90303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
90304   int jresult ;
90305   int result;
90306
90307   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
90308   jresult = (int)result;
90309   return jresult;
90310 }
90311
90312
90313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
90314   int jresult ;
90315   int result;
90316
90317   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
90318   jresult = (int)result;
90319   return jresult;
90320 }
90321
90322
90323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
90324   void * jresult ;
90325   Dali::Toolkit::ToggleButton::Property *result = 0 ;
90326
90327   {
90328     try {
90329       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
90330     } catch (std::out_of_range& e) {
90331       {
90332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90333       };
90334     } catch (std::exception& e) {
90335       {
90336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90337       };
90338     } catch (Dali::DaliException e) {
90339       {
90340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90341       };
90342     } catch (...) {
90343       {
90344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90345       };
90346     }
90347   }
90348
90349   jresult = (void *)result;
90350   return jresult;
90351 }
90352
90353
90354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
90355   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
90356
90357   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
90358   {
90359     try {
90360       delete arg1;
90361     } catch (std::out_of_range& e) {
90362       {
90363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90364       };
90365     } catch (std::exception& e) {
90366       {
90367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90368       };
90369     } catch (Dali::DaliException e) {
90370       {
90371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90372       };
90373     } catch (...) {
90374       {
90375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90376       };
90377     }
90378   }
90379
90380 }
90381
90382
90383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
90384   void * jresult ;
90385   Dali::Toolkit::ToggleButton *result = 0 ;
90386
90387   {
90388     try {
90389       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
90390     } catch (std::out_of_range& e) {
90391       {
90392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90393       };
90394     } catch (std::exception& e) {
90395       {
90396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90397       };
90398     } catch (Dali::DaliException e) {
90399       {
90400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90401       };
90402     } catch (...) {
90403       {
90404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90405       };
90406     }
90407   }
90408
90409   jresult = (void *)result;
90410   return jresult;
90411 }
90412
90413
90414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
90415   void * jresult ;
90416   Dali::Toolkit::ToggleButton *arg1 = 0 ;
90417   Dali::Toolkit::ToggleButton *result = 0 ;
90418
90419   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90420   if (!arg1) {
90421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90422     return 0;
90423   }
90424   {
90425     try {
90426       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
90427     } catch (std::out_of_range& e) {
90428       {
90429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90430       };
90431     } catch (std::exception& e) {
90432       {
90433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90434       };
90435     } catch (Dali::DaliException e) {
90436       {
90437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90438       };
90439     } catch (...) {
90440       {
90441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90442       };
90443     }
90444   }
90445
90446   jresult = (void *)result;
90447   return jresult;
90448 }
90449
90450
90451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
90452   void * jresult ;
90453   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90454   Dali::Toolkit::ToggleButton *arg2 = 0 ;
90455   Dali::Toolkit::ToggleButton *result = 0 ;
90456
90457   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90458   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
90459   if (!arg2) {
90460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
90461     return 0;
90462   }
90463   {
90464     try {
90465       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
90466     } catch (std::out_of_range& e) {
90467       {
90468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90469       };
90470     } catch (std::exception& e) {
90471       {
90472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90473       };
90474     } catch (Dali::DaliException e) {
90475       {
90476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90477       };
90478     } catch (...) {
90479       {
90480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90481       };
90482     }
90483   }
90484
90485   jresult = (void *)result;
90486   return jresult;
90487 }
90488
90489
90490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
90491   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
90492
90493   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
90494   {
90495     try {
90496       delete arg1;
90497     } catch (std::out_of_range& e) {
90498       {
90499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90500       };
90501     } catch (std::exception& e) {
90502       {
90503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90504       };
90505     } catch (Dali::DaliException e) {
90506       {
90507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90508       };
90509     } catch (...) {
90510       {
90511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90512       };
90513     }
90514   }
90515
90516 }
90517
90518
90519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
90520   void * jresult ;
90521   Dali::Toolkit::ToggleButton result;
90522
90523   {
90524     try {
90525       result = Dali::Toolkit::ToggleButton::New();
90526     } catch (std::out_of_range& e) {
90527       {
90528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90529       };
90530     } catch (std::exception& e) {
90531       {
90532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90533       };
90534     } catch (Dali::DaliException e) {
90535       {
90536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90537       };
90538     } catch (...) {
90539       {
90540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90541       };
90542     }
90543   }
90544
90545   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90546   return jresult;
90547 }
90548
90549
90550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
90551   void * jresult ;
90552   Dali::BaseHandle arg1 ;
90553   Dali::BaseHandle *argp1 ;
90554   Dali::Toolkit::ToggleButton result;
90555
90556   argp1 = (Dali::BaseHandle *)jarg1;
90557   if (!argp1) {
90558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
90559     return 0;
90560   }
90561   arg1 = *argp1;
90562   {
90563     try {
90564       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
90565     } catch (std::out_of_range& e) {
90566       {
90567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90568       };
90569     } catch (std::exception& e) {
90570       {
90571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90572       };
90573     } catch (Dali::DaliException e) {
90574       {
90575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90576       };
90577     } catch (...) {
90578       {
90579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90580       };
90581     }
90582   }
90583
90584   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
90585   return jresult;
90586 }
90587
90588
90589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
90590   void * jresult ;
90591   Dali::Toolkit::Visual::Base *result = 0 ;
90592
90593   {
90594     try {
90595       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
90596     } catch (std::out_of_range& e) {
90597       {
90598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90599       };
90600     } catch (std::exception& e) {
90601       {
90602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90603       };
90604     } catch (Dali::DaliException e) {
90605       {
90606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90607       };
90608     } catch (...) {
90609       {
90610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90611       };
90612     }
90613   }
90614
90615   jresult = (void *)result;
90616   return jresult;
90617 }
90618
90619
90620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
90621   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90622
90623   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90624   {
90625     try {
90626       delete arg1;
90627     } catch (std::out_of_range& e) {
90628       {
90629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90630       };
90631     } catch (std::exception& e) {
90632       {
90633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90634       };
90635     } catch (Dali::DaliException e) {
90636       {
90637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90638       };
90639     } catch (...) {
90640       {
90641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90642       };
90643     }
90644   }
90645
90646 }
90647
90648
90649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
90650   void * jresult ;
90651   Dali::Toolkit::Visual::Base *arg1 = 0 ;
90652   Dali::Toolkit::Visual::Base *result = 0 ;
90653
90654   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90655   if (!arg1) {
90656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90657     return 0;
90658   }
90659   {
90660     try {
90661       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
90662     } catch (std::out_of_range& e) {
90663       {
90664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90665       };
90666     } catch (std::exception& e) {
90667       {
90668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90669       };
90670     } catch (Dali::DaliException e) {
90671       {
90672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90673       };
90674     } catch (...) {
90675       {
90676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90677       };
90678     }
90679   }
90680
90681   jresult = (void *)result;
90682   return jresult;
90683 }
90684
90685
90686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
90687   void * jresult ;
90688   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90689   Dali::Toolkit::Visual::Base *arg2 = 0 ;
90690   Dali::Toolkit::Visual::Base *result = 0 ;
90691
90692   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90693   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
90694   if (!arg2) {
90695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
90696     return 0;
90697   }
90698   {
90699     try {
90700       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
90701     } catch (std::out_of_range& e) {
90702       {
90703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90704       };
90705     } catch (std::exception& e) {
90706       {
90707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90708       };
90709     } catch (Dali::DaliException e) {
90710       {
90711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90712       };
90713     } catch (...) {
90714       {
90715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90716       };
90717     }
90718   }
90719
90720   jresult = (void *)result;
90721   return jresult;
90722 }
90723
90724
90725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
90726   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90727   std::string *arg2 = 0 ;
90728
90729   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90730   if (!jarg2) {
90731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
90732     return ;
90733   }
90734   std::string arg2_str(jarg2);
90735   arg2 = &arg2_str;
90736   {
90737     try {
90738       (arg1)->SetName((std::string const &)*arg2);
90739     } catch (std::out_of_range& e) {
90740       {
90741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90742       };
90743     } catch (std::exception& e) {
90744       {
90745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90746       };
90747     } catch (Dali::DaliException e) {
90748       {
90749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90750       };
90751     } catch (...) {
90752       {
90753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90754       };
90755     }
90756   }
90757
90758
90759   //argout typemap for const std::string&
90760
90761 }
90762
90763
90764 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
90765   char * jresult ;
90766   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90767   std::string *result = 0 ;
90768
90769   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90770   {
90771     try {
90772       result = (std::string *) &(arg1)->GetName();
90773     } catch (std::out_of_range& e) {
90774       {
90775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90776       };
90777     } catch (std::exception& e) {
90778       {
90779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90780       };
90781     } catch (Dali::DaliException e) {
90782       {
90783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90784       };
90785     } catch (...) {
90786       {
90787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90788       };
90789     }
90790   }
90791
90792   jresult = SWIG_csharp_string_callback(result->c_str());
90793   return jresult;
90794 }
90795
90796
90797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
90798   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90799   Dali::Property::Map *arg2 = 0 ;
90800   Dali::Size arg3 ;
90801   Dali::Size *argp3 ;
90802
90803   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90804   arg2 = (Dali::Property::Map *)jarg2;
90805   if (!arg2) {
90806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
90807     return ;
90808   }
90809   argp3 = (Dali::Size *)jarg3;
90810   if (!argp3) {
90811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
90812     return ;
90813   }
90814   arg3 = *argp3;
90815   {
90816     try {
90817       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
90818     } catch (std::out_of_range& e) {
90819       {
90820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90821       };
90822     } catch (std::exception& e) {
90823       {
90824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90825       };
90826     } catch (Dali::DaliException e) {
90827       {
90828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90829       };
90830     } catch (...) {
90831       {
90832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90833       };
90834     }
90835   }
90836
90837 }
90838
90839
90840 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
90841   float jresult ;
90842   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90843   float arg2 ;
90844   float result;
90845
90846   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90847   arg2 = (float)jarg2;
90848   {
90849     try {
90850       result = (float)(arg1)->GetHeightForWidth(arg2);
90851     } catch (std::out_of_range& e) {
90852       {
90853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90854       };
90855     } catch (std::exception& e) {
90856       {
90857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90858       };
90859     } catch (Dali::DaliException e) {
90860       {
90861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90862       };
90863     } catch (...) {
90864       {
90865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90866       };
90867     }
90868   }
90869
90870   jresult = result;
90871   return jresult;
90872 }
90873
90874
90875 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
90876   float jresult ;
90877   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90878   float arg2 ;
90879   float result;
90880
90881   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90882   arg2 = (float)jarg2;
90883   {
90884     try {
90885       result = (float)(arg1)->GetWidthForHeight(arg2);
90886     } catch (std::out_of_range& e) {
90887       {
90888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90889       };
90890     } catch (std::exception& e) {
90891       {
90892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90893       };
90894     } catch (Dali::DaliException e) {
90895       {
90896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90897       };
90898     } catch (...) {
90899       {
90900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90901       };
90902     }
90903   }
90904
90905   jresult = result;
90906   return jresult;
90907 }
90908
90909
90910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
90911   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90912   Dali::Vector2 *arg2 = 0 ;
90913
90914   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90915   arg2 = (Dali::Vector2 *)jarg2;
90916   if (!arg2) {
90917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
90918     return ;
90919   }
90920   {
90921     try {
90922       (arg1)->GetNaturalSize(*arg2);
90923     } catch (std::out_of_range& e) {
90924       {
90925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90926       };
90927     } catch (std::exception& e) {
90928       {
90929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90930       };
90931     } catch (Dali::DaliException e) {
90932       {
90933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90934       };
90935     } catch (...) {
90936       {
90937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90938       };
90939     }
90940   }
90941
90942 }
90943
90944
90945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
90946   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90947   float arg2 ;
90948
90949   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90950   arg2 = (int)jarg2;
90951   {
90952     try {
90953       (arg1)->SetDepthIndex(arg2);
90954     } catch (std::out_of_range& e) {
90955       {
90956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90957       };
90958     } catch (std::exception& e) {
90959       {
90960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90961       };
90962     } catch (Dali::DaliException e) {
90963       {
90964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90965       };
90966     } catch (...) {
90967       {
90968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90969       };
90970     }
90971   }
90972
90973 }
90974
90975
90976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
90977   int jresult ;
90978   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
90979   int result;
90980
90981   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
90982   {
90983     try {
90984       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
90985     } catch (std::out_of_range& e) {
90986       {
90987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90988       };
90989     } catch (std::exception& e) {
90990       {
90991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90992       };
90993     } catch (Dali::DaliException e) {
90994       {
90995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90996       };
90997     } catch (...) {
90998       {
90999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91000       };
91001     }
91002   }
91003
91004   jresult = result;
91005   return jresult;
91006 }
91007
91008
91009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
91010   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
91011   Dali::Property::Map *arg2 = 0 ;
91012
91013   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
91014   arg2 = (Dali::Property::Map *)jarg2;
91015   if (!arg2) {
91016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
91017     return ;
91018   }
91019   {
91020     try {
91021       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
91022     } catch (std::out_of_range& e) {
91023       {
91024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91025       };
91026     } catch (std::exception& e) {
91027       {
91028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91029       };
91030     } catch (Dali::DaliException e) {
91031       {
91032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91033       };
91034     } catch (...) {
91035       {
91036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91037       };
91038     }
91039   }
91040
91041 }
91042
91043
91044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
91045   void * jresult ;
91046   Dali::Toolkit::VisualFactory result;
91047
91048   {
91049     try {
91050       result = Dali::Toolkit::VisualFactory::Get();
91051     } catch (std::out_of_range& e) {
91052       {
91053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91054       };
91055     } catch (std::exception& e) {
91056       {
91057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91058       };
91059     } catch (Dali::DaliException e) {
91060       {
91061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91062       };
91063     } catch (...) {
91064       {
91065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91066       };
91067     }
91068   }
91069
91070   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
91071   return jresult;
91072 }
91073
91074
91075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
91076   void * jresult ;
91077   Dali::Toolkit::VisualFactory *result = 0 ;
91078
91079   {
91080     try {
91081       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
91082     } catch (std::out_of_range& e) {
91083       {
91084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91085       };
91086     } catch (std::exception& e) {
91087       {
91088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91089       };
91090     } catch (Dali::DaliException e) {
91091       {
91092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91093       };
91094     } catch (...) {
91095       {
91096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91097       };
91098     }
91099   }
91100
91101   jresult = (void *)result;
91102   return jresult;
91103 }
91104
91105
91106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
91107   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91108
91109   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91110   {
91111     try {
91112       delete arg1;
91113     } catch (std::out_of_range& e) {
91114       {
91115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91116       };
91117     } catch (std::exception& e) {
91118       {
91119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91120       };
91121     } catch (Dali::DaliException e) {
91122       {
91123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91124       };
91125     } catch (...) {
91126       {
91127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91128       };
91129     }
91130   }
91131
91132 }
91133
91134
91135 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
91136   void * jresult ;
91137   Dali::Toolkit::VisualFactory *arg1 = 0 ;
91138   Dali::Toolkit::VisualFactory *result = 0 ;
91139
91140   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91141   if (!arg1) {
91142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91143     return 0;
91144   }
91145   {
91146     try {
91147       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
91148     } catch (std::out_of_range& e) {
91149       {
91150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91151       };
91152     } catch (std::exception& e) {
91153       {
91154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91155       };
91156     } catch (Dali::DaliException e) {
91157       {
91158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91159       };
91160     } catch (...) {
91161       {
91162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91163       };
91164     }
91165   }
91166
91167   jresult = (void *)result;
91168   return jresult;
91169 }
91170
91171
91172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
91173   void * jresult ;
91174   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91175   Dali::Toolkit::VisualFactory *arg2 = 0 ;
91176   Dali::Toolkit::VisualFactory *result = 0 ;
91177
91178   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91179   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
91180   if (!arg2) {
91181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
91182     return 0;
91183   }
91184   {
91185     try {
91186       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
91187     } catch (std::out_of_range& e) {
91188       {
91189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91190       };
91191     } catch (std::exception& e) {
91192       {
91193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91194       };
91195     } catch (Dali::DaliException e) {
91196       {
91197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91198       };
91199     } catch (...) {
91200       {
91201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91202       };
91203     }
91204   }
91205
91206   jresult = (void *)result;
91207   return jresult;
91208 }
91209
91210
91211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
91212   void * jresult ;
91213   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91214   Dali::Property::Map *arg2 = 0 ;
91215   Dali::Toolkit::Visual::Base result;
91216
91217   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91218   arg2 = (Dali::Property::Map *)jarg2;
91219   if (!arg2) {
91220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
91221     return 0;
91222   }
91223   {
91224     try {
91225       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
91226     } catch (std::out_of_range& e) {
91227       {
91228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91229       };
91230     } catch (std::exception& e) {
91231       {
91232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91233       };
91234     } catch (Dali::DaliException e) {
91235       {
91236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91237       };
91238     } catch (...) {
91239       {
91240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91241       };
91242     }
91243   }
91244
91245   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91246   return jresult;
91247 }
91248
91249
91250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
91251   void * jresult ;
91252   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91253   Dali::Image *arg2 = 0 ;
91254   Dali::Toolkit::Visual::Base result;
91255
91256   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91257   arg2 = (Dali::Image *)jarg2;
91258   if (!arg2) {
91259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
91260     return 0;
91261   }
91262   {
91263     try {
91264       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
91265     } catch (std::out_of_range& e) {
91266       {
91267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91268       };
91269     } catch (std::exception& e) {
91270       {
91271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91272       };
91273     } catch (Dali::DaliException e) {
91274       {
91275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91276       };
91277     } catch (...) {
91278       {
91279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91280       };
91281     }
91282   }
91283
91284   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91285   return jresult;
91286 }
91287
91288
91289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
91290   void * jresult ;
91291   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
91292   std::string *arg2 = 0 ;
91293   Dali::ImageDimensions arg3 ;
91294   Dali::ImageDimensions *argp3 ;
91295   Dali::Toolkit::Visual::Base result;
91296
91297   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
91298   if (!jarg2) {
91299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91300     return 0;
91301   }
91302   std::string arg2_str(jarg2);
91303   arg2 = &arg2_str;
91304   argp3 = (Dali::ImageDimensions *)jarg3;
91305   if (!argp3) {
91306     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91307     return 0;
91308   }
91309   arg3 = *argp3;
91310   {
91311     try {
91312       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
91313     } catch (std::out_of_range& e) {
91314       {
91315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91316       };
91317     } catch (std::exception& e) {
91318       {
91319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91320       };
91321     } catch (Dali::DaliException e) {
91322       {
91323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91324       };
91325     } catch (...) {
91326       {
91327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91328       };
91329     }
91330   }
91331
91332   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
91333
91334   //argout typemap for const std::string&
91335
91336   return jresult;
91337 }
91338
91339
91340 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
91341   void * jresult ;
91342   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91343
91344   {
91345     try {
91346       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
91347     } catch (std::out_of_range& e) {
91348       {
91349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91350       };
91351     } catch (std::exception& e) {
91352       {
91353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91354       };
91355     } catch (Dali::DaliException e) {
91356       {
91357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91358       };
91359     } catch (...) {
91360       {
91361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91362       };
91363     }
91364   }
91365
91366   jresult = (void *)result;
91367   return jresult;
91368 }
91369
91370
91371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
91372   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91373
91374   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91375   {
91376     try {
91377       delete arg1;
91378     } catch (std::out_of_range& e) {
91379       {
91380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91381       };
91382     } catch (std::exception& e) {
91383       {
91384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91385       };
91386     } catch (Dali::DaliException e) {
91387       {
91388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91389       };
91390     } catch (...) {
91391       {
91392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91393       };
91394     }
91395   }
91396
91397 }
91398
91399
91400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
91401   void * jresult ;
91402   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
91403   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91404
91405   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91406   if (!arg1) {
91407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91408     return 0;
91409   }
91410   {
91411     try {
91412       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
91413     } catch (std::out_of_range& e) {
91414       {
91415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91416       };
91417     } catch (std::exception& e) {
91418       {
91419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91420       };
91421     } catch (Dali::DaliException e) {
91422       {
91423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91424       };
91425     } catch (...) {
91426       {
91427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91428       };
91429     }
91430   }
91431
91432   jresult = (void *)result;
91433   return jresult;
91434 }
91435
91436
91437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
91438   void * jresult ;
91439   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91440   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
91441   Dali::Toolkit::AsyncImageLoader *result = 0 ;
91442
91443   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91444   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
91445   if (!arg2) {
91446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
91447     return 0;
91448   }
91449   {
91450     try {
91451       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
91452     } catch (std::out_of_range& e) {
91453       {
91454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91455       };
91456     } catch (std::exception& e) {
91457       {
91458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91459       };
91460     } catch (Dali::DaliException e) {
91461       {
91462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91463       };
91464     } catch (...) {
91465       {
91466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91467       };
91468     }
91469   }
91470
91471   jresult = (void *)result;
91472   return jresult;
91473 }
91474
91475
91476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
91477   void * jresult ;
91478   Dali::Toolkit::AsyncImageLoader result;
91479
91480   {
91481     try {
91482       result = Dali::Toolkit::AsyncImageLoader::New();
91483     } catch (std::out_of_range& e) {
91484       {
91485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91486       };
91487     } catch (std::exception& e) {
91488       {
91489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91490       };
91491     } catch (Dali::DaliException e) {
91492       {
91493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91494       };
91495     } catch (...) {
91496       {
91497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91498       };
91499     }
91500   }
91501
91502   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91503   return jresult;
91504 }
91505
91506
91507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
91508   void * jresult ;
91509   Dali::BaseHandle arg1 ;
91510   Dali::BaseHandle *argp1 ;
91511   Dali::Toolkit::AsyncImageLoader result;
91512
91513   argp1 = (Dali::BaseHandle *)jarg1;
91514   if (!argp1) {
91515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
91516     return 0;
91517   }
91518   arg1 = *argp1;
91519   {
91520     try {
91521       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
91522     } catch (std::out_of_range& e) {
91523       {
91524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91525       };
91526     } catch (std::exception& e) {
91527       {
91528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91529       };
91530     } catch (Dali::DaliException e) {
91531       {
91532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91533       };
91534     } catch (...) {
91535       {
91536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91537       };
91538     }
91539   }
91540
91541   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
91542   return jresult;
91543 }
91544
91545
91546 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
91547   unsigned int jresult ;
91548   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91549   std::string *arg2 = 0 ;
91550   uint32_t result;
91551
91552   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91553   if (!jarg2) {
91554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91555     return 0;
91556   }
91557   std::string arg2_str(jarg2);
91558   arg2 = &arg2_str;
91559   {
91560     try {
91561       result = (arg1)->Load((std::string const &)*arg2);
91562     } catch (std::out_of_range& e) {
91563       {
91564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91565       };
91566     } catch (std::exception& e) {
91567       {
91568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91569       };
91570     } catch (Dali::DaliException e) {
91571       {
91572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91573       };
91574     } catch (...) {
91575       {
91576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91577       };
91578     }
91579   }
91580
91581   jresult = result;
91582
91583   //argout typemap for const std::string&
91584
91585   return jresult;
91586 }
91587
91588
91589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
91590   unsigned int jresult ;
91591   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91592   std::string *arg2 = 0 ;
91593   Dali::ImageDimensions arg3 ;
91594   Dali::ImageDimensions *argp3 ;
91595   uint32_t result;
91596
91597   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91598   if (!jarg2) {
91599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91600     return 0;
91601   }
91602   std::string arg2_str(jarg2);
91603   arg2 = &arg2_str;
91604   argp3 = (Dali::ImageDimensions *)jarg3;
91605   if (!argp3) {
91606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91607     return 0;
91608   }
91609   arg3 = *argp3;
91610   {
91611     try {
91612       result = (arg1)->Load((std::string const &)*arg2,arg3);
91613     } catch (std::out_of_range& e) {
91614       {
91615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91616       };
91617     } catch (std::exception& e) {
91618       {
91619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91620       };
91621     } catch (Dali::DaliException e) {
91622       {
91623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91624       };
91625     } catch (...) {
91626       {
91627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91628       };
91629     }
91630   }
91631
91632   jresult = result;
91633
91634   //argout typemap for const std::string&
91635
91636   return jresult;
91637 }
91638
91639
91640 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
91641   unsigned int jresult ;
91642   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91643   std::string *arg2 = 0 ;
91644   Dali::ImageDimensions arg3 ;
91645   Dali::FittingMode::Type arg4 ;
91646   Dali::SamplingMode::Type arg5 ;
91647   bool arg6 ;
91648   Dali::ImageDimensions *argp3 ;
91649   uint32_t result;
91650
91651   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91652   if (!jarg2) {
91653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91654     return 0;
91655   }
91656   std::string arg2_str(jarg2);
91657   arg2 = &arg2_str;
91658   argp3 = (Dali::ImageDimensions *)jarg3;
91659   if (!argp3) {
91660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91661     return 0;
91662   }
91663   arg3 = *argp3;
91664   arg4 = (Dali::FittingMode::Type)jarg4;
91665   arg5 = (Dali::SamplingMode::Type)jarg5;
91666   arg6 = jarg6 ? true : false;
91667   {
91668     try {
91669       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
91670     } catch (std::out_of_range& e) {
91671       {
91672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91673       };
91674     } catch (std::exception& e) {
91675       {
91676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91677       };
91678     } catch (Dali::DaliException e) {
91679       {
91680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91681       };
91682     } catch (...) {
91683       {
91684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91685       };
91686     }
91687   }
91688
91689   jresult = result;
91690
91691   //argout typemap for const std::string&
91692
91693   return jresult;
91694 }
91695
91696
91697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
91698   unsigned int jresult ;
91699   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91700   uint32_t arg2 ;
91701   bool result;
91702
91703   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91704   arg2 = (uint32_t)jarg2;
91705   {
91706     try {
91707       result = (bool)(arg1)->Cancel(arg2);
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   return jresult;
91729 }
91730
91731
91732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
91733   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91734
91735   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91736   {
91737     try {
91738       (arg1)->CancelAll();
91739     } catch (std::out_of_range& e) {
91740       {
91741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91742       };
91743     } catch (std::exception& e) {
91744       {
91745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91746       };
91747     } catch (Dali::DaliException e) {
91748       {
91749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91750       };
91751     } catch (...) {
91752       {
91753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91754       };
91755     }
91756   }
91757
91758 }
91759
91760
91761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
91762   void * jresult ;
91763   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
91764   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
91765
91766   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
91767   {
91768     try {
91769       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
91770     } catch (std::out_of_range& e) {
91771       {
91772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91773       };
91774     } catch (std::exception& e) {
91775       {
91776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91777       };
91778     } catch (Dali::DaliException e) {
91779       {
91780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91781       };
91782     } catch (...) {
91783       {
91784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91785       };
91786     }
91787   }
91788
91789   jresult = (void *)result;
91790   return jresult;
91791 }
91792
91793
91794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
91795   void * jresult ;
91796   std::string *arg1 = 0 ;
91797   Dali::PixelData result;
91798
91799   if (!jarg1) {
91800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91801     return 0;
91802   }
91803   std::string arg1_str(jarg1);
91804   arg1 = &arg1_str;
91805   {
91806     try {
91807       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
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 = new Dali::PixelData((const Dali::PixelData &)result);
91828
91829   //argout typemap for const std::string&
91830
91831   return jresult;
91832 }
91833
91834
91835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
91836   void * jresult ;
91837   std::string *arg1 = 0 ;
91838   Dali::ImageDimensions arg2 ;
91839   Dali::ImageDimensions *argp2 ;
91840   Dali::PixelData result;
91841
91842   if (!jarg1) {
91843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91844     return 0;
91845   }
91846   std::string arg1_str(jarg1);
91847   arg1 = &arg1_str;
91848   argp2 = (Dali::ImageDimensions *)jarg2;
91849   if (!argp2) {
91850     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91851     return 0;
91852   }
91853   arg2 = *argp2;
91854   {
91855     try {
91856       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
91857     } catch (std::out_of_range& e) {
91858       {
91859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91860       };
91861     } catch (std::exception& e) {
91862       {
91863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91864       };
91865     } catch (Dali::DaliException e) {
91866       {
91867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91868       };
91869     } catch (...) {
91870       {
91871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91872       };
91873     }
91874   }
91875
91876   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91877
91878   //argout typemap for const std::string&
91879
91880   return jresult;
91881 }
91882
91883
91884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
91885   void * jresult ;
91886   std::string *arg1 = 0 ;
91887   Dali::ImageDimensions arg2 ;
91888   Dali::FittingMode::Type arg3 ;
91889   Dali::SamplingMode::Type arg4 ;
91890   bool arg5 ;
91891   Dali::ImageDimensions *argp2 ;
91892   Dali::PixelData result;
91893
91894   if (!jarg1) {
91895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
91896     return 0;
91897   }
91898   std::string arg1_str(jarg1);
91899   arg1 = &arg1_str;
91900   argp2 = (Dali::ImageDimensions *)jarg2;
91901   if (!argp2) {
91902     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
91903     return 0;
91904   }
91905   arg2 = *argp2;
91906   arg3 = (Dali::FittingMode::Type)jarg3;
91907   arg4 = (Dali::SamplingMode::Type)jarg4;
91908   arg5 = jarg5 ? true : false;
91909   {
91910     try {
91911       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
91912     } catch (std::out_of_range& e) {
91913       {
91914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91915       };
91916     } catch (std::exception& e) {
91917       {
91918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91919       };
91920     } catch (Dali::DaliException e) {
91921       {
91922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91923       };
91924     } catch (...) {
91925       {
91926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91927       };
91928     }
91929   }
91930
91931   jresult = new Dali::PixelData((const Dali::PixelData &)result);
91932
91933   //argout typemap for const std::string&
91934
91935   return jresult;
91936 }
91937
91938
91939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
91940   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91941
91942   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91943   {
91944     try {
91945       delete arg1;
91946     } catch (std::out_of_range& e) {
91947       {
91948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91949       };
91950     } catch (std::exception& e) {
91951       {
91952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91953       };
91954     } catch (Dali::DaliException e) {
91955       {
91956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91957       };
91958     } catch (...) {
91959       {
91960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91961       };
91962     }
91963   }
91964
91965 }
91966
91967
91968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
91969   void * jresult ;
91970   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
91971   Dali::Actor arg2 ;
91972   Dali::Actor arg3 ;
91973   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
91974   Dali::Actor *argp2 ;
91975   Dali::Actor *argp3 ;
91976   Dali::Actor result;
91977
91978   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
91979   argp2 = (Dali::Actor *)jarg2;
91980   if (!argp2) {
91981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91982     return 0;
91983   }
91984   arg2 = *argp2;
91985   argp3 = (Dali::Actor *)jarg3;
91986   if (!argp3) {
91987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91988     return 0;
91989   }
91990   arg3 = *argp3;
91991   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
91992   {
91993     try {
91994       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
91995     } catch (std::out_of_range& e) {
91996       {
91997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91998       };
91999     } catch (std::exception& e) {
92000       {
92001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92002       };
92003     } catch (Dali::DaliException e) {
92004       {
92005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92006       };
92007     } catch (...) {
92008       {
92009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92010       };
92011     }
92012   }
92013
92014   jresult = new Dali::Actor((const Dali::Actor &)result);
92015   return jresult;
92016 }
92017
92018
92019 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
92020   void * jresult ;
92021   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
92022
92023   {
92024     try {
92025       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
92026     } catch (std::out_of_range& e) {
92027       {
92028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92029       };
92030     } catch (std::exception& e) {
92031       {
92032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92033       };
92034     } catch (Dali::DaliException e) {
92035       {
92036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92037       };
92038     } catch (...) {
92039       {
92040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92041       };
92042     }
92043   }
92044
92045   jresult = (void *)result;
92046   return jresult;
92047 }
92048
92049
92050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
92051   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
92052   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
92053   if (director) {
92054     director->swig_connect_director(callback0);
92055   }
92056 }
92057
92058
92059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
92060   KeyboardFocusManager arg1 ;
92061   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
92062   KeyboardFocusManager *argp1 ;
92063
92064   argp1 = (KeyboardFocusManager *)jarg1;
92065   if (!argp1) {
92066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
92067     return ;
92068   }
92069   arg1 = *argp1;
92070   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
92071   if (!arg2) {
92072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface & type is null", 0);
92073     return ;
92074   }
92075   {
92076     try {
92077       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
92078     } catch (std::out_of_range& e) {
92079       {
92080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92081       };
92082     } catch (std::exception& e) {
92083       {
92084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92085       };
92086     } catch (Dali::DaliException e) {
92087       {
92088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92089       };
92090     } catch (...) {
92091       {
92092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92093       };
92094     }
92095   }
92096
92097 }
92098
92099
92100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
92101   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92102
92103   arg1 = (std::vector< unsigned int > *)jarg1;
92104   {
92105     try {
92106       (arg1)->clear();
92107     } catch (std::out_of_range& e) {
92108       {
92109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92110       };
92111     } catch (std::exception& e) {
92112       {
92113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92114       };
92115     } catch (Dali::DaliException e) {
92116       {
92117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92118       };
92119     } catch (...) {
92120       {
92121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92122       };
92123     }
92124   }
92125
92126 }
92127
92128
92129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
92130   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92131   unsigned int *arg2 = 0 ;
92132   unsigned int temp2 ;
92133
92134   arg1 = (std::vector< unsigned int > *)jarg1;
92135   temp2 = (unsigned int)jarg2;
92136   arg2 = &temp2;
92137   {
92138     try {
92139       (arg1)->push_back((unsigned int const &)*arg2);
92140     } catch (std::out_of_range& e) {
92141       {
92142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92143       };
92144     } catch (std::exception& e) {
92145       {
92146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92147       };
92148     } catch (Dali::DaliException e) {
92149       {
92150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92151       };
92152     } catch (...) {
92153       {
92154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92155       };
92156     }
92157   }
92158
92159 }
92160
92161
92162 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
92163   unsigned long jresult ;
92164   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92165   std::vector< unsigned int >::size_type result;
92166
92167   arg1 = (std::vector< unsigned int > *)jarg1;
92168   {
92169     try {
92170       result = ((std::vector< unsigned int > const *)arg1)->size();
92171     } catch (std::out_of_range& e) {
92172       {
92173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92174       };
92175     } catch (std::exception& e) {
92176       {
92177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92178       };
92179     } catch (Dali::DaliException e) {
92180       {
92181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92182       };
92183     } catch (...) {
92184       {
92185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92186       };
92187     }
92188   }
92189
92190   jresult = (unsigned long)result;
92191   return jresult;
92192 }
92193
92194
92195 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
92196   unsigned long jresult ;
92197   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92198   std::vector< unsigned int >::size_type result;
92199
92200   arg1 = (std::vector< unsigned int > *)jarg1;
92201   {
92202     try {
92203       result = ((std::vector< unsigned int > const *)arg1)->capacity();
92204     } catch (std::out_of_range& e) {
92205       {
92206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92207       };
92208     } catch (std::exception& e) {
92209       {
92210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92211       };
92212     } catch (Dali::DaliException e) {
92213       {
92214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92215       };
92216     } catch (...) {
92217       {
92218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92219       };
92220     }
92221   }
92222
92223   jresult = (unsigned long)result;
92224   return jresult;
92225 }
92226
92227
92228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
92229   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92230   std::vector< unsigned int >::size_type arg2 ;
92231
92232   arg1 = (std::vector< unsigned int > *)jarg1;
92233   arg2 = (std::vector< unsigned int >::size_type)jarg2;
92234   {
92235     try {
92236       (arg1)->reserve(arg2);
92237     } catch (std::out_of_range& e) {
92238       {
92239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92240       };
92241     } catch (std::exception& e) {
92242       {
92243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92244       };
92245     } catch (Dali::DaliException e) {
92246       {
92247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92248       };
92249     } catch (...) {
92250       {
92251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92252       };
92253     }
92254   }
92255
92256 }
92257
92258
92259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
92260   void * jresult ;
92261   std::vector< unsigned int > *result = 0 ;
92262
92263   {
92264     try {
92265       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
92266     } catch (std::out_of_range& e) {
92267       {
92268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92269       };
92270     } catch (std::exception& e) {
92271       {
92272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92273       };
92274     } catch (Dali::DaliException e) {
92275       {
92276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92277       };
92278     } catch (...) {
92279       {
92280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92281       };
92282     }
92283   }
92284
92285   jresult = (void *)result;
92286   return jresult;
92287 }
92288
92289
92290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
92291   void * jresult ;
92292   std::vector< unsigned int > *arg1 = 0 ;
92293   std::vector< unsigned int > *result = 0 ;
92294
92295   arg1 = (std::vector< unsigned int > *)jarg1;
92296   if (!arg1) {
92297     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92298     return 0;
92299   }
92300   {
92301     try {
92302       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
92303     } catch (std::out_of_range& e) {
92304       {
92305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92306       };
92307     } catch (std::exception& e) {
92308       {
92309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92310       };
92311     } catch (Dali::DaliException e) {
92312       {
92313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92314       };
92315     } catch (...) {
92316       {
92317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92318       };
92319     }
92320   }
92321
92322   jresult = (void *)result;
92323   return jresult;
92324 }
92325
92326
92327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
92328   void * jresult ;
92329   int arg1 ;
92330   std::vector< unsigned int > *result = 0 ;
92331
92332   arg1 = (int)jarg1;
92333   {
92334     try {
92335       try {
92336         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
92337       }
92338       catch(std::out_of_range &_e) {
92339         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92340         return 0;
92341       }
92342
92343     } catch (std::out_of_range& e) {
92344       {
92345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92346       };
92347     } catch (std::exception& e) {
92348       {
92349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92350       };
92351     } catch (Dali::DaliException e) {
92352       {
92353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92354       };
92355     } catch (...) {
92356       {
92357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92358       };
92359     }
92360   }
92361
92362   jresult = (void *)result;
92363   return jresult;
92364 }
92365
92366
92367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
92368   unsigned int jresult ;
92369   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92370   int arg2 ;
92371   unsigned int result;
92372
92373   arg1 = (std::vector< unsigned int > *)jarg1;
92374   arg2 = (int)jarg2;
92375   {
92376     try {
92377       try {
92378         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
92379       }
92380       catch(std::out_of_range &_e) {
92381         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92382         return 0;
92383       }
92384
92385     } catch (std::out_of_range& e) {
92386       {
92387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92388       };
92389     } catch (std::exception& e) {
92390       {
92391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92392       };
92393     } catch (Dali::DaliException e) {
92394       {
92395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92396       };
92397     } catch (...) {
92398       {
92399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92400       };
92401     }
92402   }
92403
92404   jresult = result;
92405   return jresult;
92406 }
92407
92408
92409 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
92410   unsigned int jresult ;
92411   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92412   int arg2 ;
92413   unsigned int *result = 0 ;
92414
92415   arg1 = (std::vector< unsigned int > *)jarg1;
92416   arg2 = (int)jarg2;
92417   {
92418     try {
92419       try {
92420         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
92421       }
92422       catch(std::out_of_range &_e) {
92423         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92424         return 0;
92425       }
92426
92427     } catch (std::out_of_range& e) {
92428       {
92429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92430       };
92431     } catch (std::exception& e) {
92432       {
92433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92434       };
92435     } catch (Dali::DaliException e) {
92436       {
92437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92438       };
92439     } catch (...) {
92440       {
92441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92442       };
92443     }
92444   }
92445
92446   jresult = *result;
92447   return jresult;
92448 }
92449
92450
92451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
92452   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92453   int arg2 ;
92454   unsigned int *arg3 = 0 ;
92455   unsigned int temp3 ;
92456
92457   arg1 = (std::vector< unsigned int > *)jarg1;
92458   arg2 = (int)jarg2;
92459   temp3 = (unsigned int)jarg3;
92460   arg3 = &temp3;
92461   {
92462     try {
92463       try {
92464         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
92465       }
92466       catch(std::out_of_range &_e) {
92467         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92468         return ;
92469       }
92470
92471     } catch (std::out_of_range& e) {
92472       {
92473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92474       };
92475     } catch (std::exception& e) {
92476       {
92477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92478       };
92479     } catch (Dali::DaliException e) {
92480       {
92481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92482       };
92483     } catch (...) {
92484       {
92485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92486       };
92487     }
92488   }
92489
92490 }
92491
92492
92493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
92494   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92495   std::vector< unsigned int > *arg2 = 0 ;
92496
92497   arg1 = (std::vector< unsigned int > *)jarg1;
92498   arg2 = (std::vector< unsigned int > *)jarg2;
92499   if (!arg2) {
92500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92501     return ;
92502   }
92503   {
92504     try {
92505       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
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_GetRange(void * jarg1, int jarg2, int jarg3) {
92529   void * jresult ;
92530   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92531   int arg2 ;
92532   int arg3 ;
92533   std::vector< unsigned int > *result = 0 ;
92534
92535   arg1 = (std::vector< unsigned int > *)jarg1;
92536   arg2 = (int)jarg2;
92537   arg3 = (int)jarg3;
92538   {
92539     try {
92540       try {
92541         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
92542       }
92543       catch(std::out_of_range &_e) {
92544         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92545         return 0;
92546       }
92547       catch(std::invalid_argument &_e) {
92548         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92549         return 0;
92550       }
92551
92552     } catch (std::out_of_range& e) {
92553       {
92554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92555       };
92556     } catch (std::exception& e) {
92557       {
92558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92559       };
92560     } catch (Dali::DaliException e) {
92561       {
92562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92563       };
92564     } catch (...) {
92565       {
92566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92567       };
92568     }
92569   }
92570
92571   jresult = (void *)result;
92572   return jresult;
92573 }
92574
92575
92576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
92577   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92578   int arg2 ;
92579   unsigned int *arg3 = 0 ;
92580   unsigned int temp3 ;
92581
92582   arg1 = (std::vector< unsigned int > *)jarg1;
92583   arg2 = (int)jarg2;
92584   temp3 = (unsigned int)jarg3;
92585   arg3 = &temp3;
92586   {
92587     try {
92588       try {
92589         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
92590       }
92591       catch(std::out_of_range &_e) {
92592         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92593         return ;
92594       }
92595
92596     } catch (std::out_of_range& e) {
92597       {
92598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92599       };
92600     } catch (std::exception& e) {
92601       {
92602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92603       };
92604     } catch (Dali::DaliException e) {
92605       {
92606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92607       };
92608     } catch (...) {
92609       {
92610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92611       };
92612     }
92613   }
92614
92615 }
92616
92617
92618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92619   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92620   int arg2 ;
92621   std::vector< unsigned int > *arg3 = 0 ;
92622
92623   arg1 = (std::vector< unsigned int > *)jarg1;
92624   arg2 = (int)jarg2;
92625   arg3 = (std::vector< unsigned int > *)jarg3;
92626   if (!arg3) {
92627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92628     return ;
92629   }
92630   {
92631     try {
92632       try {
92633         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92634       }
92635       catch(std::out_of_range &_e) {
92636         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92637         return ;
92638       }
92639
92640     } catch (std::out_of_range& e) {
92641       {
92642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92643       };
92644     } catch (std::exception& e) {
92645       {
92646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92647       };
92648     } catch (Dali::DaliException e) {
92649       {
92650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92651       };
92652     } catch (...) {
92653       {
92654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92655       };
92656     }
92657   }
92658
92659 }
92660
92661
92662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
92663   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92664   int arg2 ;
92665
92666   arg1 = (std::vector< unsigned int > *)jarg1;
92667   arg2 = (int)jarg2;
92668   {
92669     try {
92670       try {
92671         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
92672       }
92673       catch(std::out_of_range &_e) {
92674         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92675         return ;
92676       }
92677
92678     } catch (std::out_of_range& e) {
92679       {
92680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92681       };
92682     } catch (std::exception& e) {
92683       {
92684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92685       };
92686     } catch (Dali::DaliException e) {
92687       {
92688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92689       };
92690     } catch (...) {
92691       {
92692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92693       };
92694     }
92695   }
92696
92697 }
92698
92699
92700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92701   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92702   int arg2 ;
92703   int arg3 ;
92704
92705   arg1 = (std::vector< unsigned int > *)jarg1;
92706   arg2 = (int)jarg2;
92707   arg3 = (int)jarg3;
92708   {
92709     try {
92710       try {
92711         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
92712       }
92713       catch(std::out_of_range &_e) {
92714         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92715         return ;
92716       }
92717       catch(std::invalid_argument &_e) {
92718         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92719         return ;
92720       }
92721
92722     } catch (std::out_of_range& e) {
92723       {
92724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92725       };
92726     } catch (std::exception& e) {
92727       {
92728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92729       };
92730     } catch (Dali::DaliException e) {
92731       {
92732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92733       };
92734     } catch (...) {
92735       {
92736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92737       };
92738     }
92739   }
92740
92741 }
92742
92743
92744 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
92745   void * jresult ;
92746   unsigned int *arg1 = 0 ;
92747   int arg2 ;
92748   unsigned int temp1 ;
92749   std::vector< unsigned int > *result = 0 ;
92750
92751   temp1 = (unsigned int)jarg1;
92752   arg1 = &temp1;
92753   arg2 = (int)jarg2;
92754   {
92755     try {
92756       try {
92757         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
92758       }
92759       catch(std::out_of_range &_e) {
92760         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92761         return 0;
92762       }
92763
92764     } catch (std::out_of_range& e) {
92765       {
92766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92767       };
92768     } catch (std::exception& e) {
92769       {
92770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92771       };
92772     } catch (Dali::DaliException e) {
92773       {
92774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92775       };
92776     } catch (...) {
92777       {
92778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92779       };
92780     }
92781   }
92782
92783   jresult = (void *)result;
92784   return jresult;
92785 }
92786
92787
92788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
92789   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92790
92791   arg1 = (std::vector< unsigned int > *)jarg1;
92792   {
92793     try {
92794       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
92795     } catch (std::out_of_range& e) {
92796       {
92797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92798       };
92799     } catch (std::exception& e) {
92800       {
92801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92802       };
92803     } catch (Dali::DaliException e) {
92804       {
92805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92806       };
92807     } catch (...) {
92808       {
92809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92810       };
92811     }
92812   }
92813
92814 }
92815
92816
92817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92818   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92819   int arg2 ;
92820   int arg3 ;
92821
92822   arg1 = (std::vector< unsigned int > *)jarg1;
92823   arg2 = (int)jarg2;
92824   arg3 = (int)jarg3;
92825   {
92826     try {
92827       try {
92828         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92829       }
92830       catch(std::out_of_range &_e) {
92831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92832         return ;
92833       }
92834       catch(std::invalid_argument &_e) {
92835         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92836         return ;
92837       }
92838
92839     } catch (std::out_of_range& e) {
92840       {
92841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92842       };
92843     } catch (std::exception& e) {
92844       {
92845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92846       };
92847     } catch (Dali::DaliException e) {
92848       {
92849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92850       };
92851     } catch (...) {
92852       {
92853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92854       };
92855     }
92856   }
92857
92858 }
92859
92860
92861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92862   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92863   int arg2 ;
92864   std::vector< unsigned int > *arg3 = 0 ;
92865
92866   arg1 = (std::vector< unsigned int > *)jarg1;
92867   arg2 = (int)jarg2;
92868   arg3 = (std::vector< unsigned int > *)jarg3;
92869   if (!arg3) {
92870     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
92871     return ;
92872   }
92873   {
92874     try {
92875       try {
92876         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
92877       }
92878       catch(std::out_of_range &_e) {
92879         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92880         return ;
92881       }
92882
92883     } catch (std::out_of_range& e) {
92884       {
92885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92886       };
92887     } catch (std::exception& e) {
92888       {
92889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92890       };
92891     } catch (Dali::DaliException e) {
92892       {
92893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92894       };
92895     } catch (...) {
92896       {
92897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92898       };
92899     }
92900   }
92901
92902 }
92903
92904
92905 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
92906   unsigned int jresult ;
92907   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92908   unsigned int *arg2 = 0 ;
92909   unsigned int temp2 ;
92910   bool result;
92911
92912   arg1 = (std::vector< unsigned int > *)jarg1;
92913   temp2 = (unsigned int)jarg2;
92914   arg2 = &temp2;
92915   {
92916     try {
92917       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
92918     } catch (std::out_of_range& e) {
92919       {
92920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92921       };
92922     } catch (std::exception& e) {
92923       {
92924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92925       };
92926     } catch (Dali::DaliException e) {
92927       {
92928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92929       };
92930     } catch (...) {
92931       {
92932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92933       };
92934     }
92935   }
92936
92937   jresult = result;
92938   return jresult;
92939 }
92940
92941
92942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
92943   int jresult ;
92944   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92945   unsigned int *arg2 = 0 ;
92946   unsigned int temp2 ;
92947   int result;
92948
92949   arg1 = (std::vector< unsigned int > *)jarg1;
92950   temp2 = (unsigned int)jarg2;
92951   arg2 = &temp2;
92952   {
92953     try {
92954       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
92955     } catch (std::out_of_range& e) {
92956       {
92957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92958       };
92959     } catch (std::exception& e) {
92960       {
92961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92962       };
92963     } catch (Dali::DaliException e) {
92964       {
92965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92966       };
92967     } catch (...) {
92968       {
92969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92970       };
92971     }
92972   }
92973
92974   jresult = result;
92975   return jresult;
92976 }
92977
92978
92979 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
92980   int jresult ;
92981   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
92982   unsigned int *arg2 = 0 ;
92983   unsigned int temp2 ;
92984   int result;
92985
92986   arg1 = (std::vector< unsigned int > *)jarg1;
92987   temp2 = (unsigned int)jarg2;
92988   arg2 = &temp2;
92989   {
92990     try {
92991       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
92992     } catch (std::out_of_range& e) {
92993       {
92994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92995       };
92996     } catch (std::exception& e) {
92997       {
92998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92999       };
93000     } catch (Dali::DaliException e) {
93001       {
93002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93003       };
93004     } catch (...) {
93005       {
93006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93007       };
93008     }
93009   }
93010
93011   jresult = result;
93012   return jresult;
93013 }
93014
93015
93016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
93017   unsigned int jresult ;
93018   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93019   unsigned int *arg2 = 0 ;
93020   unsigned int temp2 ;
93021   bool result;
93022
93023   arg1 = (std::vector< unsigned int > *)jarg1;
93024   temp2 = (unsigned int)jarg2;
93025   arg2 = &temp2;
93026   {
93027     try {
93028       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
93029     } catch (std::out_of_range& e) {
93030       {
93031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93032       };
93033     } catch (std::exception& e) {
93034       {
93035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93036       };
93037     } catch (Dali::DaliException e) {
93038       {
93039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93040       };
93041     } catch (...) {
93042       {
93043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93044       };
93045     }
93046   }
93047
93048   jresult = result;
93049   return jresult;
93050 }
93051
93052
93053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
93054   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
93055
93056   arg1 = (std::vector< unsigned int > *)jarg1;
93057   {
93058     try {
93059       delete arg1;
93060     } catch (std::out_of_range& e) {
93061       {
93062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93063       };
93064     } catch (std::exception& e) {
93065       {
93066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93067       };
93068     } catch (Dali::DaliException e) {
93069       {
93070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93071       };
93072     } catch (...) {
93073       {
93074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93075       };
93076     }
93077   }
93078
93079 }
93080
93081
93082 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
93083   void * jresult ;
93084   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93085
93086   {
93087     try {
93088       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
93089     } catch (std::out_of_range& e) {
93090       {
93091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93092       };
93093     } catch (std::exception& e) {
93094       {
93095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93096       };
93097     } catch (Dali::DaliException e) {
93098       {
93099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93100       };
93101     } catch (...) {
93102       {
93103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93104       };
93105     }
93106   }
93107
93108   jresult = (void *)result;
93109   return jresult;
93110 }
93111
93112
93113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
93114   void * jresult ;
93115   unsigned int arg1 ;
93116   Dali::Actor arg2 ;
93117   Dali::Actor *argp2 ;
93118   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93119
93120   arg1 = (unsigned int)jarg1;
93121   argp2 = (Dali::Actor *)jarg2;
93122   if (!argp2) {
93123     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93124     return 0;
93125   }
93126   arg2 = *argp2;
93127   {
93128     try {
93129       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
93130     } catch (std::out_of_range& e) {
93131       {
93132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93133       };
93134     } catch (std::exception& e) {
93135       {
93136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93137       };
93138     } catch (Dali::DaliException e) {
93139       {
93140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93141       };
93142     } catch (...) {
93143       {
93144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93145       };
93146     }
93147   }
93148
93149   jresult = (void *)result;
93150   return jresult;
93151 }
93152
93153
93154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
93155   void * jresult ;
93156   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93157   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93158
93159   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93160   if (!arg1) {
93161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93162     return 0;
93163   }
93164   {
93165     try {
93166       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
93167     } catch (std::out_of_range& e) {
93168       {
93169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93170       };
93171     } catch (std::exception& e) {
93172       {
93173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93174       };
93175     } catch (Dali::DaliException e) {
93176       {
93177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93178       };
93179     } catch (...) {
93180       {
93181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93182       };
93183     }
93184   }
93185
93186   jresult = (void *)result;
93187   return jresult;
93188 }
93189
93190
93191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
93192   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93193   unsigned int arg2 ;
93194
93195   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93196   arg2 = (unsigned int)jarg2;
93197   if (arg1) (arg1)->first = arg2;
93198 }
93199
93200
93201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
93202   unsigned int jresult ;
93203   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93204   unsigned int result;
93205
93206   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93207   result = (unsigned int) ((arg1)->first);
93208   jresult = result;
93209   return jresult;
93210 }
93211
93212
93213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
93214   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93215   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
93216
93217   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93218   arg2 = (Dali::Actor *)jarg2;
93219   if (arg1) (arg1)->second = *arg2;
93220 }
93221
93222
93223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
93224   void * jresult ;
93225   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93226   Dali::Actor *result = 0 ;
93227
93228   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93229   result = (Dali::Actor *)& ((arg1)->second);
93230   jresult = (void *)result;
93231   return jresult;
93232 }
93233
93234
93235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
93236   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
93237
93238   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93239   {
93240     try {
93241       delete arg1;
93242     } catch (std::out_of_range& e) {
93243       {
93244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93245       };
93246     } catch (std::exception& e) {
93247       {
93248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93249       };
93250     } catch (Dali::DaliException e) {
93251       {
93252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93253       };
93254     } catch (...) {
93255       {
93256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93257       };
93258     }
93259   }
93260
93261 }
93262
93263
93264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
93265   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93266
93267   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93268   {
93269     try {
93270       (arg1)->clear();
93271     } catch (std::out_of_range& e) {
93272       {
93273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93274       };
93275     } catch (std::exception& e) {
93276       {
93277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93278       };
93279     } catch (Dali::DaliException e) {
93280       {
93281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93282       };
93283     } catch (...) {
93284       {
93285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93286       };
93287     }
93288   }
93289
93290 }
93291
93292
93293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
93294   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93295   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
93296
93297   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93298   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
93299   if (!arg2) {
93300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93301     return ;
93302   }
93303   {
93304     try {
93305       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
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 unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
93329   unsigned long jresult ;
93330   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93331   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93332
93333   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93334   {
93335     try {
93336       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
93337     } catch (std::out_of_range& e) {
93338       {
93339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93340       };
93341     } catch (std::exception& e) {
93342       {
93343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93344       };
93345     } catch (Dali::DaliException e) {
93346       {
93347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93348       };
93349     } catch (...) {
93350       {
93351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93352       };
93353     }
93354   }
93355
93356   jresult = (unsigned long)result;
93357   return jresult;
93358 }
93359
93360
93361 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
93362   unsigned long jresult ;
93363   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93364   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
93365
93366   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93367   {
93368     try {
93369       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
93370     } catch (std::out_of_range& e) {
93371       {
93372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93373       };
93374     } catch (std::exception& e) {
93375       {
93376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93377       };
93378     } catch (Dali::DaliException e) {
93379       {
93380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93381       };
93382     } catch (...) {
93383       {
93384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93385       };
93386     }
93387   }
93388
93389   jresult = (unsigned long)result;
93390   return jresult;
93391 }
93392
93393
93394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
93395   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93396   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
93397
93398   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93399   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
93400   {
93401     try {
93402       (arg1)->reserve(arg2);
93403     } catch (std::out_of_range& e) {
93404       {
93405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93406       };
93407     } catch (std::exception& e) {
93408       {
93409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93410       };
93411     } catch (Dali::DaliException e) {
93412       {
93413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93414       };
93415     } catch (...) {
93416       {
93417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93418       };
93419     }
93420   }
93421
93422 }
93423
93424
93425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
93426   void * jresult ;
93427   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93428
93429   {
93430     try {
93431       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
93432     } catch (std::out_of_range& e) {
93433       {
93434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93435       };
93436     } catch (std::exception& e) {
93437       {
93438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93439       };
93440     } catch (Dali::DaliException e) {
93441       {
93442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93443       };
93444     } catch (...) {
93445       {
93446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93447       };
93448     }
93449   }
93450
93451   jresult = (void *)result;
93452   return jresult;
93453 }
93454
93455
93456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
93457   void * jresult ;
93458   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
93459   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93460
93461   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93462   if (!arg1) {
93463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93464     return 0;
93465   }
93466   {
93467     try {
93468       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);
93469     } catch (std::out_of_range& e) {
93470       {
93471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93472       };
93473     } catch (std::exception& e) {
93474       {
93475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93476       };
93477     } catch (Dali::DaliException e) {
93478       {
93479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93480       };
93481     } catch (...) {
93482       {
93483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93484       };
93485     }
93486   }
93487
93488   jresult = (void *)result;
93489   return jresult;
93490 }
93491
93492
93493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
93494   void * jresult ;
93495   int arg1 ;
93496   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93497
93498   arg1 = (int)jarg1;
93499   {
93500     try {
93501       try {
93502         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);
93503       }
93504       catch(std::out_of_range &_e) {
93505         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93506         return 0;
93507       }
93508
93509     } catch (std::out_of_range& e) {
93510       {
93511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93512       };
93513     } catch (std::exception& e) {
93514       {
93515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93516       };
93517     } catch (Dali::DaliException e) {
93518       {
93519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93520       };
93521     } catch (...) {
93522       {
93523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93524       };
93525     }
93526   }
93527
93528   jresult = (void *)result;
93529   return jresult;
93530 }
93531
93532
93533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
93534   void * jresult ;
93535   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93536   int arg2 ;
93537   std::pair< unsigned int,Dali::Actor > result;
93538
93539   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93540   arg2 = (int)jarg2;
93541   {
93542     try {
93543       try {
93544         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
93545       }
93546       catch(std::out_of_range &_e) {
93547         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93548         return 0;
93549       }
93550
93551     } catch (std::out_of_range& e) {
93552       {
93553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93554       };
93555     } catch (std::exception& e) {
93556       {
93557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93558       };
93559     } catch (Dali::DaliException e) {
93560       {
93561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93562       };
93563     } catch (...) {
93564       {
93565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93566       };
93567     }
93568   }
93569
93570   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
93571   return jresult;
93572 }
93573
93574
93575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
93576   void * jresult ;
93577   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93578   int arg2 ;
93579   std::pair< unsigned int,Dali::Actor > *result = 0 ;
93580
93581   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93582   arg2 = (int)jarg2;
93583   {
93584     try {
93585       try {
93586         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
93587       }
93588       catch(std::out_of_range &_e) {
93589         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93590         return 0;
93591       }
93592
93593     } catch (std::out_of_range& e) {
93594       {
93595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93596       };
93597     } catch (std::exception& e) {
93598       {
93599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93600       };
93601     } catch (Dali::DaliException e) {
93602       {
93603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93604       };
93605     } catch (...) {
93606       {
93607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93608       };
93609     }
93610   }
93611
93612   jresult = (void *)result;
93613   return jresult;
93614 }
93615
93616
93617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
93618   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93619   int arg2 ;
93620   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93621
93622   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93623   arg2 = (int)jarg2;
93624   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93625   if (!arg3) {
93626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93627     return ;
93628   }
93629   {
93630     try {
93631       try {
93632         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);
93633       }
93634       catch(std::out_of_range &_e) {
93635         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93636         return ;
93637       }
93638
93639     } catch (std::out_of_range& e) {
93640       {
93641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93642       };
93643     } catch (std::exception& e) {
93644       {
93645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93646       };
93647     } catch (Dali::DaliException e) {
93648       {
93649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93650       };
93651     } catch (...) {
93652       {
93653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93654       };
93655     }
93656   }
93657
93658 }
93659
93660
93661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
93662   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93663   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
93664
93665   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93666   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
93667   if (!arg2) {
93668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93669     return ;
93670   }
93671   {
93672     try {
93673       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);
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_GetRange(void * jarg1, int jarg2, int jarg3) {
93697   void * jresult ;
93698   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93699   int arg2 ;
93700   int arg3 ;
93701   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93702
93703   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93704   arg2 = (int)jarg2;
93705   arg3 = (int)jarg3;
93706   {
93707     try {
93708       try {
93709         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);
93710       }
93711       catch(std::out_of_range &_e) {
93712         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93713         return 0;
93714       }
93715       catch(std::invalid_argument &_e) {
93716         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93717         return 0;
93718       }
93719
93720     } catch (std::out_of_range& e) {
93721       {
93722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93723       };
93724     } catch (std::exception& e) {
93725       {
93726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93727       };
93728     } catch (Dali::DaliException e) {
93729       {
93730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93731       };
93732     } catch (...) {
93733       {
93734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93735       };
93736     }
93737   }
93738
93739   jresult = (void *)result;
93740   return jresult;
93741 }
93742
93743
93744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
93745   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93746   int arg2 ;
93747   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
93748
93749   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93750   arg2 = (int)jarg2;
93751   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
93752   if (!arg3) {
93753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93754     return ;
93755   }
93756   {
93757     try {
93758       try {
93759         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);
93760       }
93761       catch(std::out_of_range &_e) {
93762         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93763         return ;
93764       }
93765
93766     } catch (std::out_of_range& e) {
93767       {
93768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93769       };
93770     } catch (std::exception& e) {
93771       {
93772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93773       };
93774     } catch (Dali::DaliException e) {
93775       {
93776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93777       };
93778     } catch (...) {
93779       {
93780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93781       };
93782     }
93783   }
93784
93785 }
93786
93787
93788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
93789   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93790   int arg2 ;
93791   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
93792
93793   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93794   arg2 = (int)jarg2;
93795   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
93796   if (!arg3) {
93797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
93798     return ;
93799   }
93800   {
93801     try {
93802       try {
93803         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);
93804       }
93805       catch(std::out_of_range &_e) {
93806         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93807         return ;
93808       }
93809
93810     } catch (std::out_of_range& e) {
93811       {
93812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93813       };
93814     } catch (std::exception& e) {
93815       {
93816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93817       };
93818     } catch (Dali::DaliException e) {
93819       {
93820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93821       };
93822     } catch (...) {
93823       {
93824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93825       };
93826     }
93827   }
93828
93829 }
93830
93831
93832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
93833   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93834   int arg2 ;
93835
93836   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93837   arg2 = (int)jarg2;
93838   {
93839     try {
93840       try {
93841         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
93842       }
93843       catch(std::out_of_range &_e) {
93844         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93845         return ;
93846       }
93847
93848     } catch (std::out_of_range& e) {
93849       {
93850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93851       };
93852     } catch (std::exception& e) {
93853       {
93854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93855       };
93856     } catch (Dali::DaliException e) {
93857       {
93858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93859       };
93860     } catch (...) {
93861       {
93862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93863       };
93864     }
93865   }
93866
93867 }
93868
93869
93870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
93871   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93872   int arg2 ;
93873   int arg3 ;
93874
93875   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93876   arg2 = (int)jarg2;
93877   arg3 = (int)jarg3;
93878   {
93879     try {
93880       try {
93881         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
93882       }
93883       catch(std::out_of_range &_e) {
93884         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93885         return ;
93886       }
93887       catch(std::invalid_argument &_e) {
93888         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
93889         return ;
93890       }
93891
93892     } catch (std::out_of_range& e) {
93893       {
93894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93895       };
93896     } catch (std::exception& e) {
93897       {
93898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93899       };
93900     } catch (Dali::DaliException e) {
93901       {
93902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93903       };
93904     } catch (...) {
93905       {
93906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93907       };
93908     }
93909   }
93910
93911 }
93912
93913
93914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
93915   void * jresult ;
93916   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
93917   int arg2 ;
93918   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
93919
93920   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
93921   if (!arg1) {
93922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
93923     return 0;
93924   }
93925   arg2 = (int)jarg2;
93926   {
93927     try {
93928       try {
93929         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);
93930       }
93931       catch(std::out_of_range &_e) {
93932         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
93933         return 0;
93934       }
93935
93936     } catch (std::out_of_range& e) {
93937       {
93938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93939       };
93940     } catch (std::exception& e) {
93941       {
93942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93943       };
93944     } catch (Dali::DaliException e) {
93945       {
93946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93947       };
93948     } catch (...) {
93949       {
93950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93951       };
93952     }
93953   }
93954
93955   jresult = (void *)result;
93956   return jresult;
93957 }
93958
93959
93960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
93961   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93962
93963   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93964   {
93965     try {
93966       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
93967     } catch (std::out_of_range& e) {
93968       {
93969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93970       };
93971     } catch (std::exception& e) {
93972       {
93973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93974       };
93975     } catch (Dali::DaliException e) {
93976       {
93977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93978       };
93979     } catch (...) {
93980       {
93981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93982       };
93983     }
93984   }
93985
93986 }
93987
93988
93989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
93990   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
93991   int arg2 ;
93992   int arg3 ;
93993
93994   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
93995   arg2 = (int)jarg2;
93996   arg3 = (int)jarg3;
93997   {
93998     try {
93999       try {
94000         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94001       }
94002       catch(std::out_of_range &_e) {
94003         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94004         return ;
94005       }
94006       catch(std::invalid_argument &_e) {
94007         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94008         return ;
94009       }
94010
94011     } catch (std::out_of_range& e) {
94012       {
94013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94014       };
94015     } catch (std::exception& e) {
94016       {
94017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94018       };
94019     } catch (Dali::DaliException e) {
94020       {
94021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94022       };
94023     } catch (...) {
94024       {
94025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94026       };
94027     }
94028   }
94029
94030 }
94031
94032
94033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94034   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94035   int arg2 ;
94036   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
94037
94038   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94039   arg2 = (int)jarg2;
94040   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
94041   if (!arg3) {
94042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
94043     return ;
94044   }
94045   {
94046     try {
94047       try {
94048         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);
94049       }
94050       catch(std::out_of_range &_e) {
94051         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94052         return ;
94053       }
94054
94055     } catch (std::out_of_range& e) {
94056       {
94057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94058       };
94059     } catch (std::exception& e) {
94060       {
94061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94062       };
94063     } catch (Dali::DaliException e) {
94064       {
94065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94066       };
94067     } catch (...) {
94068       {
94069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94070       };
94071     }
94072   }
94073
94074 }
94075
94076
94077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
94078   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
94079
94080   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
94081   {
94082     try {
94083       delete arg1;
94084     } catch (std::out_of_range& e) {
94085       {
94086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94087       };
94088     } catch (std::exception& e) {
94089       {
94090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94091       };
94092     } catch (Dali::DaliException e) {
94093       {
94094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94095       };
94096     } catch (...) {
94097       {
94098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94099       };
94100     }
94101   }
94102
94103 }
94104
94105
94106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
94107   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94108
94109   arg1 = (std::vector< Dali::Actor > *)jarg1;
94110   {
94111     try {
94112       (arg1)->clear();
94113     } catch (std::out_of_range& e) {
94114       {
94115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94116       };
94117     } catch (std::exception& e) {
94118       {
94119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94120       };
94121     } catch (Dali::DaliException e) {
94122       {
94123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94124       };
94125     } catch (...) {
94126       {
94127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94128       };
94129     }
94130   }
94131
94132 }
94133
94134
94135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
94136   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94137   Dali::Actor *arg2 = 0 ;
94138
94139   arg1 = (std::vector< Dali::Actor > *)jarg1;
94140   arg2 = (Dali::Actor *)jarg2;
94141   if (!arg2) {
94142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94143     return ;
94144   }
94145   {
94146     try {
94147       (arg1)->push_back((Dali::Actor const &)*arg2);
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 unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
94171   unsigned long jresult ;
94172   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94173   std::vector< Dali::Actor >::size_type result;
94174
94175   arg1 = (std::vector< Dali::Actor > *)jarg1;
94176   {
94177     try {
94178       result = ((std::vector< Dali::Actor > const *)arg1)->size();
94179     } catch (std::out_of_range& e) {
94180       {
94181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94182       };
94183     } catch (std::exception& e) {
94184       {
94185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94186       };
94187     } catch (Dali::DaliException e) {
94188       {
94189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94190       };
94191     } catch (...) {
94192       {
94193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94194       };
94195     }
94196   }
94197
94198   jresult = (unsigned long)result;
94199   return jresult;
94200 }
94201
94202
94203 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
94204   unsigned long jresult ;
94205   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94206   std::vector< Dali::Actor >::size_type result;
94207
94208   arg1 = (std::vector< Dali::Actor > *)jarg1;
94209   {
94210     try {
94211       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
94212     } catch (std::out_of_range& e) {
94213       {
94214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94215       };
94216     } catch (std::exception& e) {
94217       {
94218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94219       };
94220     } catch (Dali::DaliException e) {
94221       {
94222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94223       };
94224     } catch (...) {
94225       {
94226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94227       };
94228     }
94229   }
94230
94231   jresult = (unsigned long)result;
94232   return jresult;
94233 }
94234
94235
94236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
94237   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94238   std::vector< Dali::Actor >::size_type arg2 ;
94239
94240   arg1 = (std::vector< Dali::Actor > *)jarg1;
94241   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
94242   {
94243     try {
94244       (arg1)->reserve(arg2);
94245     } catch (std::out_of_range& e) {
94246       {
94247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94248       };
94249     } catch (std::exception& e) {
94250       {
94251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94252       };
94253     } catch (Dali::DaliException e) {
94254       {
94255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94256       };
94257     } catch (...) {
94258       {
94259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94260       };
94261     }
94262   }
94263
94264 }
94265
94266
94267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
94268   void * jresult ;
94269   std::vector< Dali::Actor > *result = 0 ;
94270
94271   {
94272     try {
94273       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
94274     } catch (std::out_of_range& e) {
94275       {
94276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94277       };
94278     } catch (std::exception& e) {
94279       {
94280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94281       };
94282     } catch (Dali::DaliException e) {
94283       {
94284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94285       };
94286     } catch (...) {
94287       {
94288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94289       };
94290     }
94291   }
94292
94293   jresult = (void *)result;
94294   return jresult;
94295 }
94296
94297
94298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
94299   void * jresult ;
94300   std::vector< Dali::Actor > *arg1 = 0 ;
94301   std::vector< Dali::Actor > *result = 0 ;
94302
94303   arg1 = (std::vector< Dali::Actor > *)jarg1;
94304   if (!arg1) {
94305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94306     return 0;
94307   }
94308   {
94309     try {
94310       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
94311     } catch (std::out_of_range& e) {
94312       {
94313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94314       };
94315     } catch (std::exception& e) {
94316       {
94317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94318       };
94319     } catch (Dali::DaliException e) {
94320       {
94321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94322       };
94323     } catch (...) {
94324       {
94325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94326       };
94327     }
94328   }
94329
94330   jresult = (void *)result;
94331   return jresult;
94332 }
94333
94334
94335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
94336   void * jresult ;
94337   int arg1 ;
94338   std::vector< Dali::Actor > *result = 0 ;
94339
94340   arg1 = (int)jarg1;
94341   {
94342     try {
94343       try {
94344         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
94345       }
94346       catch(std::out_of_range &_e) {
94347         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94348         return 0;
94349       }
94350
94351     } catch (std::out_of_range& e) {
94352       {
94353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94354       };
94355     } catch (std::exception& e) {
94356       {
94357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94358       };
94359     } catch (Dali::DaliException e) {
94360       {
94361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94362       };
94363     } catch (...) {
94364       {
94365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94366       };
94367     }
94368   }
94369
94370   jresult = (void *)result;
94371   return jresult;
94372 }
94373
94374
94375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
94376   void * jresult ;
94377   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94378   int arg2 ;
94379   Dali::Actor result;
94380
94381   arg1 = (std::vector< Dali::Actor > *)jarg1;
94382   arg2 = (int)jarg2;
94383   {
94384     try {
94385       try {
94386         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
94387       }
94388       catch(std::out_of_range &_e) {
94389         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94390         return 0;
94391       }
94392
94393     } catch (std::out_of_range& e) {
94394       {
94395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94396       };
94397     } catch (std::exception& e) {
94398       {
94399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94400       };
94401     } catch (Dali::DaliException e) {
94402       {
94403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94404       };
94405     } catch (...) {
94406       {
94407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94408       };
94409     }
94410   }
94411
94412   jresult = new Dali::Actor((const Dali::Actor &)result);
94413   return jresult;
94414 }
94415
94416
94417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
94418   void * jresult ;
94419   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94420   int arg2 ;
94421   Dali::Actor *result = 0 ;
94422
94423   arg1 = (std::vector< Dali::Actor > *)jarg1;
94424   arg2 = (int)jarg2;
94425   {
94426     try {
94427       try {
94428         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
94429       }
94430       catch(std::out_of_range &_e) {
94431         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94432         return 0;
94433       }
94434
94435     } catch (std::out_of_range& e) {
94436       {
94437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94438       };
94439     } catch (std::exception& e) {
94440       {
94441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94442       };
94443     } catch (Dali::DaliException e) {
94444       {
94445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94446       };
94447     } catch (...) {
94448       {
94449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94450       };
94451     }
94452   }
94453
94454   jresult = (void *)result;
94455   return jresult;
94456 }
94457
94458
94459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
94460   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94461   int arg2 ;
94462   Dali::Actor *arg3 = 0 ;
94463
94464   arg1 = (std::vector< Dali::Actor > *)jarg1;
94465   arg2 = (int)jarg2;
94466   arg3 = (Dali::Actor *)jarg3;
94467   if (!arg3) {
94468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94469     return ;
94470   }
94471   {
94472     try {
94473       try {
94474         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
94475       }
94476       catch(std::out_of_range &_e) {
94477         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94478         return ;
94479       }
94480
94481     } catch (std::out_of_range& e) {
94482       {
94483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94484       };
94485     } catch (std::exception& e) {
94486       {
94487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94488       };
94489     } catch (Dali::DaliException e) {
94490       {
94491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94492       };
94493     } catch (...) {
94494       {
94495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94496       };
94497     }
94498   }
94499
94500 }
94501
94502
94503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
94504   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94505   std::vector< Dali::Actor > *arg2 = 0 ;
94506
94507   arg1 = (std::vector< Dali::Actor > *)jarg1;
94508   arg2 = (std::vector< Dali::Actor > *)jarg2;
94509   if (!arg2) {
94510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94511     return ;
94512   }
94513   {
94514     try {
94515       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
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_GetRange(void * jarg1, int jarg2, int jarg3) {
94539   void * jresult ;
94540   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94541   int arg2 ;
94542   int arg3 ;
94543   std::vector< Dali::Actor > *result = 0 ;
94544
94545   arg1 = (std::vector< Dali::Actor > *)jarg1;
94546   arg2 = (int)jarg2;
94547   arg3 = (int)jarg3;
94548   {
94549     try {
94550       try {
94551         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
94552       }
94553       catch(std::out_of_range &_e) {
94554         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94555         return 0;
94556       }
94557       catch(std::invalid_argument &_e) {
94558         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94559         return 0;
94560       }
94561
94562     } catch (std::out_of_range& e) {
94563       {
94564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94565       };
94566     } catch (std::exception& e) {
94567       {
94568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94569       };
94570     } catch (Dali::DaliException e) {
94571       {
94572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94573       };
94574     } catch (...) {
94575       {
94576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94577       };
94578     }
94579   }
94580
94581   jresult = (void *)result;
94582   return jresult;
94583 }
94584
94585
94586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
94587   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94588   int arg2 ;
94589   Dali::Actor *arg3 = 0 ;
94590
94591   arg1 = (std::vector< Dali::Actor > *)jarg1;
94592   arg2 = (int)jarg2;
94593   arg3 = (Dali::Actor *)jarg3;
94594   if (!arg3) {
94595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94596     return ;
94597   }
94598   {
94599     try {
94600       try {
94601         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
94602       }
94603       catch(std::out_of_range &_e) {
94604         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94605         return ;
94606       }
94607
94608     } catch (std::out_of_range& e) {
94609       {
94610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94611       };
94612     } catch (std::exception& e) {
94613       {
94614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94615       };
94616     } catch (Dali::DaliException e) {
94617       {
94618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94619       };
94620     } catch (...) {
94621       {
94622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94623       };
94624     }
94625   }
94626
94627 }
94628
94629
94630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
94631   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94632   int arg2 ;
94633   std::vector< Dali::Actor > *arg3 = 0 ;
94634
94635   arg1 = (std::vector< Dali::Actor > *)jarg1;
94636   arg2 = (int)jarg2;
94637   arg3 = (std::vector< Dali::Actor > *)jarg3;
94638   if (!arg3) {
94639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94640     return ;
94641   }
94642   {
94643     try {
94644       try {
94645         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94646       }
94647       catch(std::out_of_range &_e) {
94648         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94649         return ;
94650       }
94651
94652     } catch (std::out_of_range& e) {
94653       {
94654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94655       };
94656     } catch (std::exception& e) {
94657       {
94658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94659       };
94660     } catch (Dali::DaliException e) {
94661       {
94662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94663       };
94664     } catch (...) {
94665       {
94666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94667       };
94668     }
94669   }
94670
94671 }
94672
94673
94674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
94675   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94676   int arg2 ;
94677
94678   arg1 = (std::vector< Dali::Actor > *)jarg1;
94679   arg2 = (int)jarg2;
94680   {
94681     try {
94682       try {
94683         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
94684       }
94685       catch(std::out_of_range &_e) {
94686         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94687         return ;
94688       }
94689
94690     } catch (std::out_of_range& e) {
94691       {
94692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94693       };
94694     } catch (std::exception& e) {
94695       {
94696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94697       };
94698     } catch (Dali::DaliException e) {
94699       {
94700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94701       };
94702     } catch (...) {
94703       {
94704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94705       };
94706     }
94707   }
94708
94709 }
94710
94711
94712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
94713   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94714   int arg2 ;
94715   int arg3 ;
94716
94717   arg1 = (std::vector< Dali::Actor > *)jarg1;
94718   arg2 = (int)jarg2;
94719   arg3 = (int)jarg3;
94720   {
94721     try {
94722       try {
94723         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
94724       }
94725       catch(std::out_of_range &_e) {
94726         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94727         return ;
94728       }
94729       catch(std::invalid_argument &_e) {
94730         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94731         return ;
94732       }
94733
94734     } catch (std::out_of_range& e) {
94735       {
94736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94737       };
94738     } catch (std::exception& e) {
94739       {
94740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94741       };
94742     } catch (Dali::DaliException e) {
94743       {
94744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94745       };
94746     } catch (...) {
94747       {
94748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94749       };
94750     }
94751   }
94752
94753 }
94754
94755
94756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
94757   void * jresult ;
94758   Dali::Actor *arg1 = 0 ;
94759   int arg2 ;
94760   std::vector< Dali::Actor > *result = 0 ;
94761
94762   arg1 = (Dali::Actor *)jarg1;
94763   if (!arg1) {
94764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
94765     return 0;
94766   }
94767   arg2 = (int)jarg2;
94768   {
94769     try {
94770       try {
94771         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
94772       }
94773       catch(std::out_of_range &_e) {
94774         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94775         return 0;
94776       }
94777
94778     } catch (std::out_of_range& e) {
94779       {
94780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94781       };
94782     } catch (std::exception& e) {
94783       {
94784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94785       };
94786     } catch (Dali::DaliException e) {
94787       {
94788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94789       };
94790     } catch (...) {
94791       {
94792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94793       };
94794     }
94795   }
94796
94797   jresult = (void *)result;
94798   return jresult;
94799 }
94800
94801
94802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
94803   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94804
94805   arg1 = (std::vector< Dali::Actor > *)jarg1;
94806   {
94807     try {
94808       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
94809     } catch (std::out_of_range& e) {
94810       {
94811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94812       };
94813     } catch (std::exception& e) {
94814       {
94815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94816       };
94817     } catch (Dali::DaliException e) {
94818       {
94819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94820       };
94821     } catch (...) {
94822       {
94823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94824       };
94825     }
94826   }
94827
94828 }
94829
94830
94831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
94832   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94833   int arg2 ;
94834   int arg3 ;
94835
94836   arg1 = (std::vector< Dali::Actor > *)jarg1;
94837   arg2 = (int)jarg2;
94838   arg3 = (int)jarg3;
94839   {
94840     try {
94841       try {
94842         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
94843       }
94844       catch(std::out_of_range &_e) {
94845         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94846         return ;
94847       }
94848       catch(std::invalid_argument &_e) {
94849         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
94850         return ;
94851       }
94852
94853     } catch (std::out_of_range& e) {
94854       {
94855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94856       };
94857     } catch (std::exception& e) {
94858       {
94859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94860       };
94861     } catch (Dali::DaliException e) {
94862       {
94863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94864       };
94865     } catch (...) {
94866       {
94867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94868       };
94869     }
94870   }
94871
94872 }
94873
94874
94875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
94876   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94877   int arg2 ;
94878   std::vector< Dali::Actor > *arg3 = 0 ;
94879
94880   arg1 = (std::vector< Dali::Actor > *)jarg1;
94881   arg2 = (int)jarg2;
94882   arg3 = (std::vector< Dali::Actor > *)jarg3;
94883   if (!arg3) {
94884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
94885     return ;
94886   }
94887   {
94888     try {
94889       try {
94890         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
94891       }
94892       catch(std::out_of_range &_e) {
94893         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
94894         return ;
94895       }
94896
94897     } catch (std::out_of_range& e) {
94898       {
94899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94900       };
94901     } catch (std::exception& e) {
94902       {
94903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94904       };
94905     } catch (Dali::DaliException e) {
94906       {
94907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94908       };
94909     } catch (...) {
94910       {
94911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94912       };
94913     }
94914   }
94915
94916 }
94917
94918
94919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
94920   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
94921
94922   arg1 = (std::vector< Dali::Actor > *)jarg1;
94923   {
94924     try {
94925       delete arg1;
94926     } catch (std::out_of_range& e) {
94927       {
94928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94929       };
94930     } catch (std::exception& e) {
94931       {
94932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94933       };
94934     } catch (Dali::DaliException e) {
94935       {
94936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94937       };
94938     } catch (...) {
94939       {
94940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94941       };
94942     }
94943   }
94944
94945 }
94946
94947
94948 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
94949   unsigned int jresult ;
94950   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94951   bool result;
94952
94953   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94954   {
94955     try {
94956       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94957     } catch (std::out_of_range& e) {
94958       {
94959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94960       };
94961     } catch (std::exception& e) {
94962       {
94963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94964       };
94965     } catch (Dali::DaliException e) {
94966       {
94967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94968       };
94969     } catch (...) {
94970       {
94971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94972       };
94973     }
94974   }
94975
94976   jresult = result;
94977   return jresult;
94978 }
94979
94980
94981 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
94982   unsigned long jresult ;
94983   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
94984   std::size_t result;
94985
94986   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
94987   {
94988     try {
94989       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
94990     } catch (std::out_of_range& e) {
94991       {
94992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94993       };
94994     } catch (std::exception& e) {
94995       {
94996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94997       };
94998     } catch (Dali::DaliException e) {
94999       {
95000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95001       };
95002     } catch (...) {
95003       {
95004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95005       };
95006     }
95007   }
95008
95009   jresult = (unsigned long)result;
95010   return jresult;
95011 }
95012
95013
95014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
95015   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95016   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95017
95018   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95019   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95020   {
95021     try {
95022       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
95023     } catch (std::out_of_range& e) {
95024       {
95025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95026       };
95027     } catch (std::exception& e) {
95028       {
95029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95030       };
95031     } catch (Dali::DaliException e) {
95032       {
95033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95034       };
95035     } catch (...) {
95036       {
95037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95038       };
95039     }
95040   }
95041
95042 }
95043
95044
95045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
95046   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95047   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
95048
95049   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95050   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
95051   {
95052     try {
95053       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
95054     } catch (std::out_of_range& e) {
95055       {
95056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95057       };
95058     } catch (std::exception& e) {
95059       {
95060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95061       };
95062     } catch (Dali::DaliException e) {
95063       {
95064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95065       };
95066     } catch (...) {
95067       {
95068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95069       };
95070     }
95071   }
95072
95073 }
95074
95075
95076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
95077   unsigned int jresult ;
95078   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95079   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
95080   bool result;
95081
95082   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95083   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
95084   if (!arg2) {
95085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
95086     return 0;
95087   }
95088   {
95089     try {
95090       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
95091     } catch (std::out_of_range& e) {
95092       {
95093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95094       };
95095     } catch (std::exception& e) {
95096       {
95097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95098       };
95099     } catch (Dali::DaliException e) {
95100       {
95101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95102       };
95103     } catch (...) {
95104       {
95105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95106       };
95107     }
95108   }
95109
95110   jresult = result;
95111   return jresult;
95112 }
95113
95114
95115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
95116   void * jresult ;
95117   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
95118
95119   {
95120     try {
95121       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
95122     } catch (std::out_of_range& e) {
95123       {
95124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95125       };
95126     } catch (std::exception& e) {
95127       {
95128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95129       };
95130     } catch (Dali::DaliException e) {
95131       {
95132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95133       };
95134     } catch (...) {
95135       {
95136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95137       };
95138     }
95139   }
95140
95141   jresult = (void *)result;
95142   return jresult;
95143 }
95144
95145
95146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
95147   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
95148
95149   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
95150   {
95151     try {
95152       delete arg1;
95153     } catch (std::out_of_range& e) {
95154       {
95155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95156       };
95157     } catch (std::exception& e) {
95158       {
95159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95160       };
95161     } catch (Dali::DaliException e) {
95162       {
95163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95164       };
95165     } catch (...) {
95166       {
95167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95168       };
95169     }
95170   }
95171
95172 }
95173
95174
95175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
95176   unsigned int jresult ;
95177   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95178   bool result;
95179
95180   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95181   {
95182     try {
95183       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);
95184     } catch (std::out_of_range& e) {
95185       {
95186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95187       };
95188     } catch (std::exception& e) {
95189       {
95190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95191       };
95192     } catch (Dali::DaliException e) {
95193       {
95194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95195       };
95196     } catch (...) {
95197       {
95198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95199       };
95200     }
95201   }
95202
95203   jresult = result;
95204   return jresult;
95205 }
95206
95207
95208 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
95209   unsigned long jresult ;
95210   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95211   std::size_t result;
95212
95213   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95214   {
95215     try {
95216       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);
95217     } catch (std::out_of_range& e) {
95218       {
95219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95220       };
95221     } catch (std::exception& e) {
95222       {
95223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95224       };
95225     } catch (Dali::DaliException e) {
95226       {
95227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95228       };
95229     } catch (...) {
95230       {
95231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95232       };
95233     }
95234   }
95235
95236   jresult = (unsigned long)result;
95237   return jresult;
95238 }
95239
95240
95241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
95242   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95243   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95244
95245   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95246   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95247   {
95248     try {
95249       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
95250     } catch (std::out_of_range& e) {
95251       {
95252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95253       };
95254     } catch (std::exception& e) {
95255       {
95256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95257       };
95258     } catch (Dali::DaliException e) {
95259       {
95260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95261       };
95262     } catch (...) {
95263       {
95264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95265       };
95266     }
95267   }
95268
95269 }
95270
95271
95272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
95273   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95274   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
95275
95276   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95277   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
95278   {
95279     try {
95280       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
95281     } catch (std::out_of_range& e) {
95282       {
95283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95284       };
95285     } catch (std::exception& e) {
95286       {
95287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95288       };
95289     } catch (Dali::DaliException e) {
95290       {
95291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95292       };
95293     } catch (...) {
95294       {
95295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95296       };
95297     }
95298   }
95299
95300 }
95301
95302
95303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95304   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95305   Dali::Actor arg2 ;
95306   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
95307   Dali::Actor *argp2 ;
95308
95309   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95310   argp2 = (Dali::Actor *)jarg2;
95311   if (!argp2) {
95312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95313     return ;
95314   }
95315   arg2 = *argp2;
95316   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
95317   {
95318     try {
95319       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
95320     } catch (std::out_of_range& e) {
95321       {
95322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95323       };
95324     } catch (std::exception& e) {
95325       {
95326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95327       };
95328     } catch (Dali::DaliException e) {
95329       {
95330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95331       };
95332     } catch (...) {
95333       {
95334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95335       };
95336     }
95337   }
95338
95339 }
95340
95341
95342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
95343   void * jresult ;
95344   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
95345
95346   {
95347     try {
95348       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
95349     } catch (std::out_of_range& e) {
95350       {
95351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95352       };
95353     } catch (std::exception& e) {
95354       {
95355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95356       };
95357     } catch (Dali::DaliException e) {
95358       {
95359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95360       };
95361     } catch (...) {
95362       {
95363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95364       };
95365     }
95366   }
95367
95368   jresult = (void *)result;
95369   return jresult;
95370 }
95371
95372
95373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
95374   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
95375
95376   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
95377   {
95378     try {
95379       delete arg1;
95380     } catch (std::out_of_range& e) {
95381       {
95382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95383       };
95384     } catch (std::exception& e) {
95385       {
95386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95387       };
95388     } catch (Dali::DaliException e) {
95389       {
95390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95391       };
95392     } catch (...) {
95393       {
95394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95395       };
95396     }
95397   }
95398
95399 }
95400
95401
95402 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
95403   unsigned int jresult ;
95404   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95405   bool result;
95406
95407   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95408   {
95409     try {
95410       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95411     } catch (std::out_of_range& e) {
95412       {
95413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95414       };
95415     } catch (std::exception& e) {
95416       {
95417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95418       };
95419     } catch (Dali::DaliException e) {
95420       {
95421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95422       };
95423     } catch (...) {
95424       {
95425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95426       };
95427     }
95428   }
95429
95430   jresult = result;
95431   return jresult;
95432 }
95433
95434
95435 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
95436   unsigned long jresult ;
95437   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95438   std::size_t result;
95439
95440   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95441   {
95442     try {
95443       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
95444     } catch (std::out_of_range& e) {
95445       {
95446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95447       };
95448     } catch (std::exception& e) {
95449       {
95450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95451       };
95452     } catch (Dali::DaliException e) {
95453       {
95454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95455       };
95456     } catch (...) {
95457       {
95458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95459       };
95460     }
95461   }
95462
95463   jresult = (unsigned long)result;
95464   return jresult;
95465 }
95466
95467
95468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
95469   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95470   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95471
95472   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95473   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95474   {
95475     try {
95476       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
95477     } catch (std::out_of_range& e) {
95478       {
95479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95480       };
95481     } catch (std::exception& e) {
95482       {
95483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95484       };
95485     } catch (Dali::DaliException e) {
95486       {
95487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95488       };
95489     } catch (...) {
95490       {
95491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95492       };
95493     }
95494   }
95495
95496 }
95497
95498
95499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95500   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95501   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
95502
95503   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95504   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
95505   {
95506     try {
95507       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
95508     } catch (std::out_of_range& e) {
95509       {
95510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95511       };
95512     } catch (std::exception& e) {
95513       {
95514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95515       };
95516     } catch (Dali::DaliException e) {
95517       {
95518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95519       };
95520     } catch (...) {
95521       {
95522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95523       };
95524     }
95525   }
95526
95527 }
95528
95529
95530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95531   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95532   Dali::Actor arg2 ;
95533   Dali::Actor arg3 ;
95534   Dali::Actor *argp2 ;
95535   Dali::Actor *argp3 ;
95536
95537   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95538   argp2 = (Dali::Actor *)jarg2;
95539   if (!argp2) {
95540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95541     return ;
95542   }
95543   arg2 = *argp2;
95544   argp3 = (Dali::Actor *)jarg3;
95545   if (!argp3) {
95546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95547     return ;
95548   }
95549   arg3 = *argp3;
95550   {
95551     try {
95552       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
95553     } catch (std::out_of_range& e) {
95554       {
95555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95556       };
95557     } catch (std::exception& e) {
95558       {
95559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95560       };
95561     } catch (Dali::DaliException e) {
95562       {
95563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95564       };
95565     } catch (...) {
95566       {
95567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95568       };
95569     }
95570   }
95571
95572 }
95573
95574
95575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
95576   void * jresult ;
95577   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
95578
95579   {
95580     try {
95581       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
95582     } catch (std::out_of_range& e) {
95583       {
95584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95585       };
95586     } catch (std::exception& e) {
95587       {
95588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95589       };
95590     } catch (Dali::DaliException e) {
95591       {
95592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95593       };
95594     } catch (...) {
95595       {
95596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95597       };
95598     }
95599   }
95600
95601   jresult = (void *)result;
95602   return jresult;
95603 }
95604
95605
95606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
95607   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
95608
95609   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
95610   {
95611     try {
95612       delete arg1;
95613     } catch (std::out_of_range& e) {
95614       {
95615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95616       };
95617     } catch (std::exception& e) {
95618       {
95619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95620       };
95621     } catch (Dali::DaliException e) {
95622       {
95623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95624       };
95625     } catch (...) {
95626       {
95627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95628       };
95629     }
95630   }
95631
95632 }
95633
95634
95635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
95636   unsigned int jresult ;
95637   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95638   bool result;
95639
95640   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95641   {
95642     try {
95643       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95644     } catch (std::out_of_range& e) {
95645       {
95646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95647       };
95648     } catch (std::exception& e) {
95649       {
95650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95651       };
95652     } catch (Dali::DaliException e) {
95653       {
95654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95655       };
95656     } catch (...) {
95657       {
95658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95659       };
95660     }
95661   }
95662
95663   jresult = result;
95664   return jresult;
95665 }
95666
95667
95668 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
95669   unsigned long jresult ;
95670   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95671   std::size_t result;
95672
95673   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95674   {
95675     try {
95676       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
95677     } catch (std::out_of_range& e) {
95678       {
95679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95680       };
95681     } catch (std::exception& e) {
95682       {
95683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95684       };
95685     } catch (Dali::DaliException e) {
95686       {
95687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95688       };
95689     } catch (...) {
95690       {
95691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95692       };
95693     }
95694   }
95695
95696   jresult = (unsigned long)result;
95697   return jresult;
95698 }
95699
95700
95701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
95702   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95703   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95704
95705   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95706   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95707   {
95708     try {
95709       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
95710     } catch (std::out_of_range& e) {
95711       {
95712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95713       };
95714     } catch (std::exception& e) {
95715       {
95716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95717       };
95718     } catch (Dali::DaliException e) {
95719       {
95720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95721       };
95722     } catch (...) {
95723       {
95724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95725       };
95726     }
95727   }
95728
95729 }
95730
95731
95732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95733   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95734   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
95735
95736   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95737   arg2 = (void (*)(Dali::Actor,bool))jarg2;
95738   {
95739     try {
95740       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
95741     } catch (std::out_of_range& e) {
95742       {
95743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95744       };
95745     } catch (std::exception& e) {
95746       {
95747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95748       };
95749     } catch (Dali::DaliException e) {
95750       {
95751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95752       };
95753     } catch (...) {
95754       {
95755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95756       };
95757     }
95758   }
95759
95760 }
95761
95762
95763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
95764   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95765   Dali::Actor arg2 ;
95766   bool arg3 ;
95767   Dali::Actor *argp2 ;
95768
95769   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95770   argp2 = (Dali::Actor *)jarg2;
95771   if (!argp2) {
95772     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
95773     return ;
95774   }
95775   arg2 = *argp2;
95776   arg3 = jarg3 ? true : false;
95777   {
95778     try {
95779       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
95780     } catch (std::out_of_range& e) {
95781       {
95782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95783       };
95784     } catch (std::exception& e) {
95785       {
95786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95787       };
95788     } catch (Dali::DaliException e) {
95789       {
95790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95791       };
95792     } catch (...) {
95793       {
95794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95795       };
95796     }
95797   }
95798
95799 }
95800
95801
95802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
95803   void * jresult ;
95804   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
95805
95806   {
95807     try {
95808       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
95809     } catch (std::out_of_range& e) {
95810       {
95811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95812       };
95813     } catch (std::exception& e) {
95814       {
95815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95816       };
95817     } catch (Dali::DaliException e) {
95818       {
95819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95820       };
95821     } catch (...) {
95822       {
95823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95824       };
95825     }
95826   }
95827
95828   jresult = (void *)result;
95829   return jresult;
95830 }
95831
95832
95833 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
95834   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
95835
95836   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
95837   {
95838     try {
95839       delete arg1;
95840     } catch (std::out_of_range& e) {
95841       {
95842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95843       };
95844     } catch (std::exception& e) {
95845       {
95846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95847       };
95848     } catch (Dali::DaliException e) {
95849       {
95850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95851       };
95852     } catch (...) {
95853       {
95854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95855       };
95856     }
95857   }
95858
95859 }
95860
95861
95862 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
95863   unsigned int jresult ;
95864   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95865   bool result;
95866
95867   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95868   {
95869     try {
95870       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);
95871     } catch (std::out_of_range& e) {
95872       {
95873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95874       };
95875     } catch (std::exception& e) {
95876       {
95877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95878       };
95879     } catch (Dali::DaliException e) {
95880       {
95881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95882       };
95883     } catch (...) {
95884       {
95885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95886       };
95887     }
95888   }
95889
95890   jresult = result;
95891   return jresult;
95892 }
95893
95894
95895 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
95896   unsigned long jresult ;
95897   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95898   std::size_t result;
95899
95900   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95901   {
95902     try {
95903       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);
95904     } catch (std::out_of_range& e) {
95905       {
95906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95907       };
95908     } catch (std::exception& e) {
95909       {
95910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95911       };
95912     } catch (Dali::DaliException e) {
95913       {
95914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95915       };
95916     } catch (...) {
95917       {
95918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95919       };
95920     }
95921   }
95922
95923   jresult = (unsigned long)result;
95924   return jresult;
95925 }
95926
95927
95928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
95929   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95930   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95931
95932   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95933   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95934   {
95935     try {
95936       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
95937     } catch (std::out_of_range& e) {
95938       {
95939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95940       };
95941     } catch (std::exception& e) {
95942       {
95943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95944       };
95945     } catch (Dali::DaliException e) {
95946       {
95947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95948       };
95949     } catch (...) {
95950       {
95951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95952       };
95953     }
95954   }
95955
95956 }
95957
95958
95959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95960   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95961   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
95962
95963   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95964   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
95965   {
95966     try {
95967       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
95968     } catch (std::out_of_range& e) {
95969       {
95970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95971       };
95972     } catch (std::exception& e) {
95973       {
95974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95975       };
95976     } catch (Dali::DaliException e) {
95977       {
95978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95979       };
95980     } catch (...) {
95981       {
95982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95983       };
95984     }
95985   }
95986
95987 }
95988
95989
95990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
95991   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
95992   Dali::Toolkit::StyleManager arg2 ;
95993   Dali::StyleChange::Type arg3 ;
95994   Dali::Toolkit::StyleManager *argp2 ;
95995
95996   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
95997   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
95998   if (!argp2) {
95999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
96000     return ;
96001   }
96002   arg2 = *argp2;
96003   arg3 = (Dali::StyleChange::Type)jarg3;
96004   {
96005     try {
96006       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
96007     } catch (std::out_of_range& e) {
96008       {
96009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96010       };
96011     } catch (std::exception& e) {
96012       {
96013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96014       };
96015     } catch (Dali::DaliException e) {
96016       {
96017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96018       };
96019     } catch (...) {
96020       {
96021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96022       };
96023     }
96024   }
96025
96026 }
96027
96028
96029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
96030   void * jresult ;
96031   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
96032
96033   {
96034     try {
96035       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
96036     } catch (std::out_of_range& e) {
96037       {
96038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96039       };
96040     } catch (std::exception& e) {
96041       {
96042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96043       };
96044     } catch (Dali::DaliException e) {
96045       {
96046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96047       };
96048     } catch (...) {
96049       {
96050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96051       };
96052     }
96053   }
96054
96055   jresult = (void *)result;
96056   return jresult;
96057 }
96058
96059
96060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
96061   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
96062
96063   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
96064   {
96065     try {
96066       delete arg1;
96067     } catch (std::out_of_range& e) {
96068       {
96069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96070       };
96071     } catch (std::exception& e) {
96072       {
96073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96074       };
96075     } catch (Dali::DaliException e) {
96076       {
96077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96078       };
96079     } catch (...) {
96080       {
96081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96082       };
96083     }
96084   }
96085
96086 }
96087
96088
96089 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
96090   unsigned int jresult ;
96091   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96092   bool result;
96093
96094   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96095   {
96096     try {
96097       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96098     } catch (std::out_of_range& e) {
96099       {
96100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96101       };
96102     } catch (std::exception& e) {
96103       {
96104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96105       };
96106     } catch (Dali::DaliException e) {
96107       {
96108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96109       };
96110     } catch (...) {
96111       {
96112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96113       };
96114     }
96115   }
96116
96117   jresult = result;
96118   return jresult;
96119 }
96120
96121
96122 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
96123   unsigned long jresult ;
96124   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96125   std::size_t result;
96126
96127   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96128   {
96129     try {
96130       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
96131     } catch (std::out_of_range& e) {
96132       {
96133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96134       };
96135     } catch (std::exception& e) {
96136       {
96137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96138       };
96139     } catch (Dali::DaliException e) {
96140       {
96141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96142       };
96143     } catch (...) {
96144       {
96145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96146       };
96147     }
96148   }
96149
96150   jresult = (unsigned long)result;
96151   return jresult;
96152 }
96153
96154
96155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
96156   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96157   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96158
96159   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96160   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96161   {
96162     try {
96163       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
96164     } catch (std::out_of_range& e) {
96165       {
96166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96167       };
96168     } catch (std::exception& e) {
96169       {
96170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96171       };
96172     } catch (Dali::DaliException e) {
96173       {
96174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96175       };
96176     } catch (...) {
96177       {
96178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96179       };
96180     }
96181   }
96182
96183 }
96184
96185
96186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
96187   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96188   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
96189
96190   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96191   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
96192   {
96193     try {
96194       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
96195     } catch (std::out_of_range& e) {
96196       {
96197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96198       };
96199     } catch (std::exception& e) {
96200       {
96201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96202       };
96203     } catch (Dali::DaliException e) {
96204       {
96205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96206       };
96207     } catch (...) {
96208       {
96209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96210       };
96211     }
96212   }
96213
96214 }
96215
96216
96217 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
96218   unsigned int jresult ;
96219   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96220   Dali::Toolkit::Button arg2 ;
96221   Dali::Toolkit::Button *argp2 ;
96222   bool result;
96223
96224   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96225   argp2 = (Dali::Toolkit::Button *)jarg2;
96226   if (!argp2) {
96227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
96228     return 0;
96229   }
96230   arg2 = *argp2;
96231   {
96232     try {
96233       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
96234     } catch (std::out_of_range& e) {
96235       {
96236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96237       };
96238     } catch (std::exception& e) {
96239       {
96240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96241       };
96242     } catch (Dali::DaliException e) {
96243       {
96244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96245       };
96246     } catch (...) {
96247       {
96248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96249       };
96250     }
96251   }
96252
96253   jresult = result;
96254   return jresult;
96255 }
96256
96257
96258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
96259   void * jresult ;
96260   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
96261
96262   {
96263     try {
96264       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
96265     } catch (std::out_of_range& e) {
96266       {
96267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96268       };
96269     } catch (std::exception& e) {
96270       {
96271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96272       };
96273     } catch (Dali::DaliException e) {
96274       {
96275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96276       };
96277     } catch (...) {
96278       {
96279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96280       };
96281     }
96282   }
96283
96284   jresult = (void *)result;
96285   return jresult;
96286 }
96287
96288
96289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
96290   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
96291
96292   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
96293   {
96294     try {
96295       delete arg1;
96296     } catch (std::out_of_range& e) {
96297       {
96298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96299       };
96300     } catch (std::exception& e) {
96301       {
96302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96303       };
96304     } catch (Dali::DaliException e) {
96305       {
96306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96307       };
96308     } catch (...) {
96309       {
96310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96311       };
96312     }
96313   }
96314
96315 }
96316
96317
96318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
96319   unsigned int jresult ;
96320   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96321   bool result;
96322
96323   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96324   {
96325     try {
96326       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96327     } catch (std::out_of_range& e) {
96328       {
96329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96330       };
96331     } catch (std::exception& e) {
96332       {
96333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96334       };
96335     } catch (Dali::DaliException e) {
96336       {
96337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96338       };
96339     } catch (...) {
96340       {
96341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96342       };
96343     }
96344   }
96345
96346   jresult = result;
96347   return jresult;
96348 }
96349
96350
96351 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
96352   unsigned long jresult ;
96353   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96354   std::size_t result;
96355
96356   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96357   {
96358     try {
96359       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
96360     } catch (std::out_of_range& e) {
96361       {
96362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96363       };
96364     } catch (std::exception& e) {
96365       {
96366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96367       };
96368     } catch (Dali::DaliException e) {
96369       {
96370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96371       };
96372     } catch (...) {
96373       {
96374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96375       };
96376     }
96377   }
96378
96379   jresult = (unsigned long)result;
96380   return jresult;
96381 }
96382
96383
96384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
96385   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96386   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96387
96388   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96389   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96390   {
96391     try {
96392       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
96393     } catch (std::out_of_range& e) {
96394       {
96395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96396       };
96397     } catch (std::exception& e) {
96398       {
96399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96400       };
96401     } catch (Dali::DaliException e) {
96402       {
96403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96404       };
96405     } catch (...) {
96406       {
96407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96408       };
96409     }
96410   }
96411
96412 }
96413
96414
96415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
96416   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96417   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
96418
96419   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96420   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
96421   {
96422     try {
96423       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
96424     } catch (std::out_of_range& e) {
96425       {
96426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96427       };
96428     } catch (std::exception& e) {
96429       {
96430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96431       };
96432     } catch (Dali::DaliException e) {
96433       {
96434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96435       };
96436     } catch (...) {
96437       {
96438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96439       };
96440     }
96441   }
96442
96443 }
96444
96445
96446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
96447   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96448   Dali::Toolkit::GaussianBlurView arg2 ;
96449   Dali::Toolkit::GaussianBlurView *argp2 ;
96450
96451   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96452   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
96453   if (!argp2) {
96454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
96455     return ;
96456   }
96457   arg2 = *argp2;
96458   {
96459     try {
96460       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
96461     } catch (std::out_of_range& e) {
96462       {
96463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96464       };
96465     } catch (std::exception& e) {
96466       {
96467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96468       };
96469     } catch (Dali::DaliException e) {
96470       {
96471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96472       };
96473     } catch (...) {
96474       {
96475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96476       };
96477     }
96478   }
96479
96480 }
96481
96482
96483 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
96484   void * jresult ;
96485   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
96486
96487   {
96488     try {
96489       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
96490     } catch (std::out_of_range& e) {
96491       {
96492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96493       };
96494     } catch (std::exception& e) {
96495       {
96496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96497       };
96498     } catch (Dali::DaliException e) {
96499       {
96500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96501       };
96502     } catch (...) {
96503       {
96504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96505       };
96506     }
96507   }
96508
96509   jresult = (void *)result;
96510   return jresult;
96511 }
96512
96513
96514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
96515   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
96516
96517   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
96518   {
96519     try {
96520       delete arg1;
96521     } catch (std::out_of_range& e) {
96522       {
96523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96524       };
96525     } catch (std::exception& e) {
96526       {
96527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96528       };
96529     } catch (Dali::DaliException e) {
96530       {
96531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96532       };
96533     } catch (...) {
96534       {
96535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96536       };
96537     }
96538   }
96539
96540 }
96541
96542
96543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
96544   unsigned int jresult ;
96545   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96546   bool result;
96547
96548   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96549   {
96550     try {
96551       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);
96552     } catch (std::out_of_range& e) {
96553       {
96554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96555       };
96556     } catch (std::exception& e) {
96557       {
96558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96559       };
96560     } catch (Dali::DaliException e) {
96561       {
96562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96563       };
96564     } catch (...) {
96565       {
96566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96567       };
96568     }
96569   }
96570
96571   jresult = result;
96572   return jresult;
96573 }
96574
96575
96576 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
96577   unsigned long jresult ;
96578   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96579   std::size_t result;
96580
96581   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96582   {
96583     try {
96584       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);
96585     } catch (std::out_of_range& e) {
96586       {
96587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96588       };
96589     } catch (std::exception& e) {
96590       {
96591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96592       };
96593     } catch (Dali::DaliException e) {
96594       {
96595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96596       };
96597     } catch (...) {
96598       {
96599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96600       };
96601     }
96602   }
96603
96604   jresult = (unsigned long)result;
96605   return jresult;
96606 }
96607
96608
96609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
96610   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96611   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96612
96613   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96614   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96615   {
96616     try {
96617       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
96618     } catch (std::out_of_range& e) {
96619       {
96620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96621       };
96622     } catch (std::exception& e) {
96623       {
96624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96625       };
96626     } catch (Dali::DaliException e) {
96627       {
96628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96629       };
96630     } catch (...) {
96631       {
96632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96633       };
96634     }
96635   }
96636
96637 }
96638
96639
96640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
96641   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96642   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
96643
96644   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96645   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
96646   {
96647     try {
96648       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
96649     } catch (std::out_of_range& e) {
96650       {
96651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96652       };
96653     } catch (std::exception& e) {
96654       {
96655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96656       };
96657     } catch (Dali::DaliException e) {
96658       {
96659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96660       };
96661     } catch (...) {
96662       {
96663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96664       };
96665     }
96666   }
96667
96668 }
96669
96670
96671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
96672   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96673   Dali::Toolkit::PageTurnView arg2 ;
96674   unsigned int arg3 ;
96675   bool arg4 ;
96676   Dali::Toolkit::PageTurnView *argp2 ;
96677
96678   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96679   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96680   if (!argp2) {
96681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96682     return ;
96683   }
96684   arg2 = *argp2;
96685   arg3 = (unsigned int)jarg3;
96686   arg4 = jarg4 ? true : false;
96687   {
96688     try {
96689       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
96690     } catch (std::out_of_range& e) {
96691       {
96692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96693       };
96694     } catch (std::exception& e) {
96695       {
96696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96697       };
96698     } catch (Dali::DaliException e) {
96699       {
96700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96701       };
96702     } catch (...) {
96703       {
96704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96705       };
96706     }
96707   }
96708
96709 }
96710
96711
96712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
96713   void * jresult ;
96714   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
96715
96716   {
96717     try {
96718       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
96719     } catch (std::out_of_range& e) {
96720       {
96721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96722       };
96723     } catch (std::exception& e) {
96724       {
96725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96726       };
96727     } catch (Dali::DaliException e) {
96728       {
96729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96730       };
96731     } catch (...) {
96732       {
96733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96734       };
96735     }
96736   }
96737
96738   jresult = (void *)result;
96739   return jresult;
96740 }
96741
96742
96743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
96744   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
96745
96746   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
96747   {
96748     try {
96749       delete arg1;
96750     } catch (std::out_of_range& e) {
96751       {
96752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96753       };
96754     } catch (std::exception& e) {
96755       {
96756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96757       };
96758     } catch (Dali::DaliException e) {
96759       {
96760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96761       };
96762     } catch (...) {
96763       {
96764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96765       };
96766     }
96767   }
96768
96769 }
96770
96771
96772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
96773   unsigned int jresult ;
96774   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96775   bool result;
96776
96777   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96778   {
96779     try {
96780       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96781     } catch (std::out_of_range& e) {
96782       {
96783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96784       };
96785     } catch (std::exception& e) {
96786       {
96787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96788       };
96789     } catch (Dali::DaliException e) {
96790       {
96791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96792       };
96793     } catch (...) {
96794       {
96795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96796       };
96797     }
96798   }
96799
96800   jresult = result;
96801   return jresult;
96802 }
96803
96804
96805 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
96806   unsigned long jresult ;
96807   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96808   std::size_t result;
96809
96810   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96811   {
96812     try {
96813       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
96814     } catch (std::out_of_range& e) {
96815       {
96816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96817       };
96818     } catch (std::exception& e) {
96819       {
96820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96821       };
96822     } catch (Dali::DaliException e) {
96823       {
96824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96825       };
96826     } catch (...) {
96827       {
96828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96829       };
96830     }
96831   }
96832
96833   jresult = (unsigned long)result;
96834   return jresult;
96835 }
96836
96837
96838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
96839   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96840   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96841
96842   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96843   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96844   {
96845     try {
96846       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
96847     } catch (std::out_of_range& e) {
96848       {
96849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96850       };
96851     } catch (std::exception& e) {
96852       {
96853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96854       };
96855     } catch (Dali::DaliException e) {
96856       {
96857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96858       };
96859     } catch (...) {
96860       {
96861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96862       };
96863     }
96864   }
96865
96866 }
96867
96868
96869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
96870   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96871   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
96872
96873   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96874   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
96875   {
96876     try {
96877       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
96878     } catch (std::out_of_range& e) {
96879       {
96880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96881       };
96882     } catch (std::exception& e) {
96883       {
96884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96885       };
96886     } catch (Dali::DaliException e) {
96887       {
96888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96889       };
96890     } catch (...) {
96891       {
96892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96893       };
96894     }
96895   }
96896
96897 }
96898
96899
96900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
96901   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96902   Dali::Toolkit::PageTurnView arg2 ;
96903   Dali::Toolkit::PageTurnView *argp2 ;
96904
96905   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96906   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
96907   if (!argp2) {
96908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
96909     return ;
96910   }
96911   arg2 = *argp2;
96912   {
96913     try {
96914       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
96915     } catch (std::out_of_range& e) {
96916       {
96917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96918       };
96919     } catch (std::exception& e) {
96920       {
96921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96922       };
96923     } catch (Dali::DaliException e) {
96924       {
96925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96926       };
96927     } catch (...) {
96928       {
96929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96930       };
96931     }
96932   }
96933
96934 }
96935
96936
96937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
96938   void * jresult ;
96939   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
96940
96941   {
96942     try {
96943       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
96944     } catch (std::out_of_range& e) {
96945       {
96946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96947       };
96948     } catch (std::exception& e) {
96949       {
96950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96951       };
96952     } catch (Dali::DaliException e) {
96953       {
96954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96955       };
96956     } catch (...) {
96957       {
96958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96959       };
96960     }
96961   }
96962
96963   jresult = (void *)result;
96964   return jresult;
96965 }
96966
96967
96968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
96969   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
96970
96971   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
96972   {
96973     try {
96974       delete arg1;
96975     } catch (std::out_of_range& e) {
96976       {
96977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96978       };
96979     } catch (std::exception& e) {
96980       {
96981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96982       };
96983     } catch (Dali::DaliException e) {
96984       {
96985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96986       };
96987     } catch (...) {
96988       {
96989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96990       };
96991     }
96992   }
96993
96994 }
96995
96996
96997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
96998   unsigned int jresult ;
96999   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97000   bool result;
97001
97002   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97003   {
97004     try {
97005       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);
97006     } catch (std::out_of_range& e) {
97007       {
97008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97009       };
97010     } catch (std::exception& e) {
97011       {
97012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97013       };
97014     } catch (Dali::DaliException e) {
97015       {
97016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97017       };
97018     } catch (...) {
97019       {
97020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97021       };
97022     }
97023   }
97024
97025   jresult = result;
97026   return jresult;
97027 }
97028
97029
97030 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
97031   unsigned long jresult ;
97032   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97033   std::size_t result;
97034
97035   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97036   {
97037     try {
97038       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);
97039     } catch (std::out_of_range& e) {
97040       {
97041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97042       };
97043     } catch (std::exception& e) {
97044       {
97045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97046       };
97047     } catch (Dali::DaliException e) {
97048       {
97049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97050       };
97051     } catch (...) {
97052       {
97053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97054       };
97055     }
97056   }
97057
97058   jresult = (unsigned long)result;
97059   return jresult;
97060 }
97061
97062
97063 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
97064   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97065   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97066
97067   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97068   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97069   {
97070     try {
97071       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
97072     } catch (std::out_of_range& e) {
97073       {
97074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97075       };
97076     } catch (std::exception& e) {
97077       {
97078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97079       };
97080     } catch (Dali::DaliException e) {
97081       {
97082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97083       };
97084     } catch (...) {
97085       {
97086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97087       };
97088     }
97089   }
97090
97091 }
97092
97093
97094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
97095   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97096   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
97097
97098   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97099   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
97100   {
97101     try {
97102       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
97103     } catch (std::out_of_range& e) {
97104       {
97105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97106       };
97107     } catch (std::exception& e) {
97108       {
97109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97110       };
97111     } catch (Dali::DaliException e) {
97112       {
97113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97114       };
97115     } catch (...) {
97116       {
97117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97118       };
97119     }
97120   }
97121
97122 }
97123
97124
97125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
97126   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97127   Dali::Toolkit::ProgressBar arg2 ;
97128   float arg3 ;
97129   float arg4 ;
97130   Dali::Toolkit::ProgressBar *argp2 ;
97131
97132   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97133   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
97134   if (!argp2) {
97135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
97136     return ;
97137   }
97138   arg2 = *argp2;
97139   arg3 = (float)jarg3;
97140   arg4 = (float)jarg4;
97141   {
97142     try {
97143       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
97144     } catch (std::out_of_range& e) {
97145       {
97146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97147       };
97148     } catch (std::exception& e) {
97149       {
97150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97151       };
97152     } catch (Dali::DaliException e) {
97153       {
97154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97155       };
97156     } catch (...) {
97157       {
97158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97159       };
97160     }
97161   }
97162
97163 }
97164
97165
97166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
97167   void * jresult ;
97168   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
97169
97170   {
97171     try {
97172       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
97173     } catch (std::out_of_range& e) {
97174       {
97175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97176       };
97177     } catch (std::exception& e) {
97178       {
97179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97180       };
97181     } catch (Dali::DaliException e) {
97182       {
97183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97184       };
97185     } catch (...) {
97186       {
97187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97188       };
97189     }
97190   }
97191
97192   jresult = (void *)result;
97193   return jresult;
97194 }
97195
97196
97197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
97198   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
97199
97200   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
97201   {
97202     try {
97203       delete arg1;
97204     } catch (std::out_of_range& e) {
97205       {
97206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97207       };
97208     } catch (std::exception& e) {
97209       {
97210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97211       };
97212     } catch (Dali::DaliException e) {
97213       {
97214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97215       };
97216     } catch (...) {
97217       {
97218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97219       };
97220     }
97221   }
97222
97223 }
97224
97225
97226 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
97227   unsigned int jresult ;
97228   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97229   bool result;
97230
97231   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97232   {
97233     try {
97234       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);
97235     } catch (std::out_of_range& e) {
97236       {
97237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97238       };
97239     } catch (std::exception& e) {
97240       {
97241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97242       };
97243     } catch (Dali::DaliException e) {
97244       {
97245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97246       };
97247     } catch (...) {
97248       {
97249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97250       };
97251     }
97252   }
97253
97254   jresult = result;
97255   return jresult;
97256 }
97257
97258
97259 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
97260   unsigned long jresult ;
97261   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97262   std::size_t result;
97263
97264   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97265   {
97266     try {
97267       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);
97268     } catch (std::out_of_range& e) {
97269       {
97270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97271       };
97272     } catch (std::exception& e) {
97273       {
97274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97275       };
97276     } catch (Dali::DaliException e) {
97277       {
97278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97279       };
97280     } catch (...) {
97281       {
97282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97283       };
97284     }
97285   }
97286
97287   jresult = (unsigned long)result;
97288   return jresult;
97289 }
97290
97291
97292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
97293   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97294   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97295
97296   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97297   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97298   {
97299     try {
97300       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97301     } catch (std::out_of_range& e) {
97302       {
97303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97304       };
97305     } catch (std::exception& e) {
97306       {
97307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97308       };
97309     } catch (Dali::DaliException e) {
97310       {
97311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97312       };
97313     } catch (...) {
97314       {
97315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97316       };
97317     }
97318   }
97319
97320 }
97321
97322
97323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
97324   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97325   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
97326
97327   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97328   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
97329   {
97330     try {
97331       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97332     } catch (std::out_of_range& e) {
97333       {
97334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97335       };
97336     } catch (std::exception& e) {
97337       {
97338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97339       };
97340     } catch (Dali::DaliException e) {
97341       {
97342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97343       };
97344     } catch (...) {
97345       {
97346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97347       };
97348     }
97349   }
97350
97351 }
97352
97353
97354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
97355   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97356   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
97357
97358   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97359   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
97360   if (!arg2) {
97361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
97362     return ;
97363   }
97364   {
97365     try {
97366       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*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_new_ScrollViewSnapStartedSignal() {
97390   void * jresult ;
97391   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
97392
97393   {
97394     try {
97395       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
97396     } catch (std::out_of_range& e) {
97397       {
97398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97399       };
97400     } catch (std::exception& e) {
97401       {
97402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97403       };
97404     } catch (Dali::DaliException e) {
97405       {
97406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97407       };
97408     } catch (...) {
97409       {
97410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97411       };
97412     }
97413   }
97414
97415   jresult = (void *)result;
97416   return jresult;
97417 }
97418
97419
97420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
97421   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
97422
97423   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
97424   {
97425     try {
97426       delete arg1;
97427     } catch (std::out_of_range& e) {
97428       {
97429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97430       };
97431     } catch (std::exception& e) {
97432       {
97433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97434       };
97435     } catch (Dali::DaliException e) {
97436       {
97437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97438       };
97439     } catch (...) {
97440       {
97441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97442       };
97443     }
97444   }
97445
97446 }
97447
97448
97449 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
97450   unsigned int jresult ;
97451   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97452   bool result;
97453
97454   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97455   {
97456     try {
97457       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97458     } catch (std::out_of_range& e) {
97459       {
97460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97461       };
97462     } catch (std::exception& e) {
97463       {
97464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97465       };
97466     } catch (Dali::DaliException e) {
97467       {
97468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97469       };
97470     } catch (...) {
97471       {
97472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97473       };
97474     }
97475   }
97476
97477   jresult = result;
97478   return jresult;
97479 }
97480
97481
97482 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
97483   unsigned long jresult ;
97484   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97485   std::size_t result;
97486
97487   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97488   {
97489     try {
97490       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
97491     } catch (std::out_of_range& e) {
97492       {
97493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97494       };
97495     } catch (std::exception& e) {
97496       {
97497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97498       };
97499     } catch (Dali::DaliException e) {
97500       {
97501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97502       };
97503     } catch (...) {
97504       {
97505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97506       };
97507     }
97508   }
97509
97510   jresult = (unsigned long)result;
97511   return jresult;
97512 }
97513
97514
97515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
97516   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97517   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97518
97519   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97520   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97521   {
97522     try {
97523       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97524     } catch (std::out_of_range& e) {
97525       {
97526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97527       };
97528     } catch (std::exception& e) {
97529       {
97530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97531       };
97532     } catch (Dali::DaliException e) {
97533       {
97534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97535       };
97536     } catch (...) {
97537       {
97538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97539       };
97540     }
97541   }
97542
97543 }
97544
97545
97546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
97547   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97548   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
97549
97550   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97551   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
97552   {
97553     try {
97554       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97555     } catch (std::out_of_range& e) {
97556       {
97557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97558       };
97559     } catch (std::exception& e) {
97560       {
97561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97562       };
97563     } catch (Dali::DaliException e) {
97564       {
97565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97566       };
97567     } catch (...) {
97568       {
97569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97570       };
97571     }
97572   }
97573
97574 }
97575
97576
97577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
97578   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97579   Dali::Vector2 *arg2 = 0 ;
97580
97581   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97582   arg2 = (Dali::Vector2 *)jarg2;
97583   if (!arg2) {
97584     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
97585     return ;
97586   }
97587   {
97588     try {
97589       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*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_new_ScrollableSignal() {
97613   void * jresult ;
97614   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
97615
97616   {
97617     try {
97618       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
97619     } catch (std::out_of_range& e) {
97620       {
97621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97622       };
97623     } catch (std::exception& e) {
97624       {
97625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97626       };
97627     } catch (Dali::DaliException e) {
97628       {
97629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97630       };
97631     } catch (...) {
97632       {
97633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97634       };
97635     }
97636   }
97637
97638   jresult = (void *)result;
97639   return jresult;
97640 }
97641
97642
97643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
97644   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
97645
97646   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
97647   {
97648     try {
97649       delete arg1;
97650     } catch (std::out_of_range& e) {
97651       {
97652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97653       };
97654     } catch (std::exception& e) {
97655       {
97656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97657       };
97658     } catch (Dali::DaliException e) {
97659       {
97660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97661       };
97662     } catch (...) {
97663       {
97664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97665       };
97666     }
97667   }
97668
97669 }
97670
97671
97672
97673 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
97674   unsigned int jresult ;
97675   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97676   bool result;
97677
97678   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97679   {
97680     try {
97681       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);
97682     } catch (std::out_of_range& e) {
97683       {
97684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97685       };
97686     } catch (std::exception& e) {
97687       {
97688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97689       };
97690     } catch (Dali::DaliException e) {
97691       {
97692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97693       };
97694     } catch (...) {
97695       {
97696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97697       };
97698     }
97699   }
97700
97701   jresult = result;
97702   return jresult;
97703 }
97704
97705
97706 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
97707   unsigned long jresult ;
97708   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97709   std::size_t result;
97710
97711   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97712   {
97713     try {
97714       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);
97715     } catch (std::out_of_range& e) {
97716       {
97717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97718       };
97719     } catch (std::exception& e) {
97720       {
97721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97722       };
97723     } catch (Dali::DaliException e) {
97724       {
97725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97726       };
97727     } catch (...) {
97728       {
97729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97730       };
97731     }
97732   }
97733
97734   jresult = (unsigned long)result;
97735   return jresult;
97736 }
97737
97738
97739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
97740   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97741   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97742
97743   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97744   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97745   {
97746     try {
97747       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
97748     } catch (std::out_of_range& e) {
97749       {
97750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97751       };
97752     } catch (std::exception& e) {
97753       {
97754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97755       };
97756     } catch (Dali::DaliException e) {
97757       {
97758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97759       };
97760     } catch (...) {
97761       {
97762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97763       };
97764     }
97765   }
97766
97767 }
97768
97769
97770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
97771   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97772   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
97773
97774   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97775   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
97776   {
97777     try {
97778       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
97779     } catch (std::out_of_range& e) {
97780       {
97781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97782       };
97783     } catch (std::exception& e) {
97784       {
97785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97786       };
97787     } catch (Dali::DaliException e) {
97788       {
97789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97790       };
97791     } catch (...) {
97792       {
97793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97794       };
97795     }
97796   }
97797
97798 }
97799
97800
97801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
97802   unsigned int jresult ;
97803   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97804   Dali::Toolkit::Control arg2 ;
97805   Dali::KeyEvent *arg3 = 0 ;
97806   Dali::Toolkit::Control *argp2 ;
97807   bool result;
97808
97809   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97810   argp2 = (Dali::Toolkit::Control *)jarg2;
97811   if (!argp2) {
97812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
97813     return 0;
97814   }
97815   arg2 = *argp2;
97816   arg3 = (Dali::KeyEvent *)jarg3;
97817   if (!arg3) {
97818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
97819     return 0;
97820   }
97821   {
97822     try {
97823       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);
97824     } catch (std::out_of_range& e) {
97825       {
97826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97827       };
97828     } catch (std::exception& e) {
97829       {
97830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97831       };
97832     } catch (Dali::DaliException e) {
97833       {
97834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97835       };
97836     } catch (...) {
97837       {
97838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97839       };
97840     }
97841   }
97842
97843   jresult = result;
97844   return jresult;
97845 }
97846
97847
97848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
97849   void * jresult ;
97850   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
97851
97852   {
97853     try {
97854       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
97855     } catch (std::out_of_range& e) {
97856       {
97857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97858       };
97859     } catch (std::exception& e) {
97860       {
97861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97862       };
97863     } catch (Dali::DaliException e) {
97864       {
97865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97866       };
97867     } catch (...) {
97868       {
97869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97870       };
97871     }
97872   }
97873
97874   jresult = (void *)result;
97875   return jresult;
97876 }
97877
97878
97879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
97880   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
97881
97882   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
97883   {
97884     try {
97885       delete arg1;
97886     } catch (std::out_of_range& e) {
97887       {
97888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97889       };
97890     } catch (std::exception& e) {
97891       {
97892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97893       };
97894     } catch (Dali::DaliException e) {
97895       {
97896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97897       };
97898     } catch (...) {
97899       {
97900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97901       };
97902     }
97903   }
97904
97905 }
97906
97907
97908 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
97909   unsigned int jresult ;
97910   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97911   bool result;
97912
97913   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97914   {
97915     try {
97916       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97917     } catch (std::out_of_range& e) {
97918       {
97919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97920       };
97921     } catch (std::exception& e) {
97922       {
97923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97924       };
97925     } catch (Dali::DaliException e) {
97926       {
97927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97928       };
97929     } catch (...) {
97930       {
97931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97932       };
97933     }
97934   }
97935
97936   jresult = result;
97937   return jresult;
97938 }
97939
97940
97941 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
97942   unsigned long jresult ;
97943   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97944   std::size_t result;
97945
97946   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97947   {
97948     try {
97949       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
97950     } catch (std::out_of_range& e) {
97951       {
97952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97953       };
97954     } catch (std::exception& e) {
97955       {
97956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97957       };
97958     } catch (Dali::DaliException e) {
97959       {
97960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97961       };
97962     } catch (...) {
97963       {
97964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97965       };
97966     }
97967   }
97968
97969   jresult = (unsigned long)result;
97970   return jresult;
97971 }
97972
97973
97974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
97975   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
97976   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
97977
97978   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
97979   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
97980   {
97981     try {
97982       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
97983     } catch (std::out_of_range& e) {
97984       {
97985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97986       };
97987     } catch (std::exception& e) {
97988       {
97989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97990       };
97991     } catch (Dali::DaliException e) {
97992       {
97993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97994       };
97995     } catch (...) {
97996       {
97997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97998       };
97999     }
98000   }
98001
98002 }
98003
98004
98005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
98006   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98007   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98008
98009   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98010   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98011   {
98012     try {
98013       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98014     } catch (std::out_of_range& e) {
98015       {
98016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98017       };
98018     } catch (std::exception& e) {
98019       {
98020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98021       };
98022     } catch (Dali::DaliException e) {
98023       {
98024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98025       };
98026     } catch (...) {
98027       {
98028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98029       };
98030     }
98031   }
98032
98033 }
98034
98035
98036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
98037   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98038   Dali::Toolkit::Control arg2 ;
98039   Dali::Toolkit::Control *argp2 ;
98040
98041   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98042   argp2 = (Dali::Toolkit::Control *)jarg2;
98043   if (!argp2) {
98044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98045     return ;
98046   }
98047   arg2 = *argp2;
98048   {
98049     try {
98050       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98051     } catch (std::out_of_range& e) {
98052       {
98053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98054       };
98055     } catch (std::exception& e) {
98056       {
98057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98058       };
98059     } catch (Dali::DaliException e) {
98060       {
98061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98062       };
98063     } catch (...) {
98064       {
98065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98066       };
98067     }
98068   }
98069
98070 }
98071
98072
98073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
98074   void * jresult ;
98075   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98076
98077   {
98078     try {
98079       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98080     } catch (std::out_of_range& e) {
98081       {
98082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98083       };
98084     } catch (std::exception& e) {
98085       {
98086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98087       };
98088     } catch (Dali::DaliException e) {
98089       {
98090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98091       };
98092     } catch (...) {
98093       {
98094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98095       };
98096     }
98097   }
98098
98099   jresult = (void *)result;
98100   return jresult;
98101 }
98102
98103
98104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
98105   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98106
98107   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98108   {
98109     try {
98110       delete arg1;
98111     } catch (std::out_of_range& e) {
98112       {
98113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98114       };
98115     } catch (std::exception& e) {
98116       {
98117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98118       };
98119     } catch (Dali::DaliException e) {
98120       {
98121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98122       };
98123     } catch (...) {
98124       {
98125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98126       };
98127     }
98128   }
98129
98130 }
98131
98132
98133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
98134   unsigned int jresult ;
98135   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98136   bool result;
98137
98138   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98139   {
98140     try {
98141       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98142     } catch (std::out_of_range& e) {
98143       {
98144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98145       };
98146     } catch (std::exception& e) {
98147       {
98148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98149       };
98150     } catch (Dali::DaliException e) {
98151       {
98152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98153       };
98154     } catch (...) {
98155       {
98156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98157       };
98158     }
98159   }
98160
98161   jresult = result;
98162   return jresult;
98163 }
98164
98165
98166 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
98167   unsigned long jresult ;
98168   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98169   std::size_t result;
98170
98171   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98172   {
98173     try {
98174       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
98175     } catch (std::out_of_range& e) {
98176       {
98177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98178       };
98179     } catch (std::exception& e) {
98180       {
98181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98182       };
98183     } catch (Dali::DaliException e) {
98184       {
98185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98186       };
98187     } catch (...) {
98188       {
98189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98190       };
98191     }
98192   }
98193
98194   jresult = (unsigned long)result;
98195   return jresult;
98196 }
98197
98198
98199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
98200   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98201   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98202
98203   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98204   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98205   {
98206     try {
98207       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
98208     } catch (std::out_of_range& e) {
98209       {
98210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98211       };
98212     } catch (std::exception& e) {
98213       {
98214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98215       };
98216     } catch (Dali::DaliException e) {
98217       {
98218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98219       };
98220     } catch (...) {
98221       {
98222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98223       };
98224     }
98225   }
98226
98227 }
98228
98229
98230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
98231   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98232   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
98233
98234   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98235   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
98236   {
98237     try {
98238       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
98239     } catch (std::out_of_range& e) {
98240       {
98241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98242       };
98243     } catch (std::exception& e) {
98244       {
98245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98246       };
98247     } catch (Dali::DaliException e) {
98248       {
98249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98250       };
98251     } catch (...) {
98252       {
98253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98254       };
98255     }
98256   }
98257
98258 }
98259
98260
98261 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
98262   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98263   Dali::Toolkit::VideoView *arg2 = 0 ;
98264
98265   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98266   arg2 = (Dali::Toolkit::VideoView *)jarg2;
98267   if (!arg2) {
98268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
98269     return ;
98270   }
98271   {
98272     try {
98273       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(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_new_VideoViewSignal() {
98297   void * jresult ;
98298   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
98299
98300   {
98301     try {
98302       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
98303     } catch (std::out_of_range& e) {
98304       {
98305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98306       };
98307     } catch (std::exception& e) {
98308       {
98309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98310       };
98311     } catch (Dali::DaliException e) {
98312       {
98313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98314       };
98315     } catch (...) {
98316       {
98317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98318       };
98319     }
98320   }
98321
98322   jresult = (void *)result;
98323   return jresult;
98324 }
98325
98326
98327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
98328   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
98329
98330   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
98331   {
98332     try {
98333       delete arg1;
98334     } catch (std::out_of_range& e) {
98335       {
98336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98337       };
98338     } catch (std::exception& e) {
98339       {
98340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98341       };
98342     } catch (Dali::DaliException e) {
98343       {
98344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98345       };
98346     } catch (...) {
98347       {
98348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98349       };
98350     }
98351   }
98352
98353 }
98354
98355
98356 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
98357   unsigned int jresult ;
98358   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98359   bool result;
98360
98361   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98362   {
98363     try {
98364       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98365     } catch (std::out_of_range& e) {
98366       {
98367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98368       };
98369     } catch (std::exception& e) {
98370       {
98371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98372       };
98373     } catch (Dali::DaliException e) {
98374       {
98375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98376       };
98377     } catch (...) {
98378       {
98379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98380       };
98381     }
98382   }
98383
98384   jresult = result;
98385   return jresult;
98386 }
98387
98388
98389 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
98390   unsigned long jresult ;
98391   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98392   std::size_t result;
98393
98394   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98395   {
98396     try {
98397       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
98398     } catch (std::out_of_range& e) {
98399       {
98400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98401       };
98402     } catch (std::exception& e) {
98403       {
98404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98405       };
98406     } catch (Dali::DaliException e) {
98407       {
98408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98409       };
98410     } catch (...) {
98411       {
98412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98413       };
98414     }
98415   }
98416
98417   jresult = (unsigned long)result;
98418   return jresult;
98419 }
98420
98421
98422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
98423   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98424   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98425
98426   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98427   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98428   {
98429     try {
98430       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
98431     } catch (std::out_of_range& e) {
98432       {
98433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98434       };
98435     } catch (std::exception& e) {
98436       {
98437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98438       };
98439     } catch (Dali::DaliException e) {
98440       {
98441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98442       };
98443     } catch (...) {
98444       {
98445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98446       };
98447     }
98448   }
98449
98450 }
98451
98452
98453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
98454   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98455   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
98456
98457   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98458   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
98459   {
98460     try {
98461       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
98462     } catch (std::out_of_range& e) {
98463       {
98464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98465       };
98466     } catch (std::exception& e) {
98467       {
98468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98469       };
98470     } catch (Dali::DaliException e) {
98471       {
98472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98473       };
98474     } catch (...) {
98475       {
98476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98477       };
98478     }
98479   }
98480
98481 }
98482
98483
98484 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
98485   unsigned int jresult ;
98486   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98487   Dali::Toolkit::Slider arg2 ;
98488   float arg3 ;
98489   Dali::Toolkit::Slider *argp2 ;
98490   bool result;
98491
98492   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98493   argp2 = (Dali::Toolkit::Slider *)jarg2;
98494   if (!argp2) {
98495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98496     return 0;
98497   }
98498   arg2 = *argp2;
98499   arg3 = (float)jarg3;
98500   {
98501     try {
98502       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
98503     } catch (std::out_of_range& e) {
98504       {
98505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98506       };
98507     } catch (std::exception& e) {
98508       {
98509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98510       };
98511     } catch (Dali::DaliException e) {
98512       {
98513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98514       };
98515     } catch (...) {
98516       {
98517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98518       };
98519     }
98520   }
98521
98522   jresult = result;
98523   return jresult;
98524 }
98525
98526
98527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
98528   void * jresult ;
98529   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
98530
98531   {
98532     try {
98533       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
98534     } catch (std::out_of_range& e) {
98535       {
98536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98537       };
98538     } catch (std::exception& e) {
98539       {
98540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98541       };
98542     } catch (Dali::DaliException e) {
98543       {
98544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98545       };
98546     } catch (...) {
98547       {
98548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98549       };
98550     }
98551   }
98552
98553   jresult = (void *)result;
98554   return jresult;
98555 }
98556
98557
98558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
98559   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
98560
98561   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
98562   {
98563     try {
98564       delete arg1;
98565     } catch (std::out_of_range& e) {
98566       {
98567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98568       };
98569     } catch (std::exception& e) {
98570       {
98571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98572       };
98573     } catch (Dali::DaliException e) {
98574       {
98575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98576       };
98577     } catch (...) {
98578       {
98579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98580       };
98581     }
98582   }
98583
98584 }
98585
98586
98587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
98588   unsigned int jresult ;
98589   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98590   bool result;
98591
98592   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98593   {
98594     try {
98595       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98596     } catch (std::out_of_range& e) {
98597       {
98598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98599       };
98600     } catch (std::exception& e) {
98601       {
98602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98603       };
98604     } catch (Dali::DaliException e) {
98605       {
98606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98607       };
98608     } catch (...) {
98609       {
98610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98611       };
98612     }
98613   }
98614
98615   jresult = result;
98616   return jresult;
98617 }
98618
98619
98620 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
98621   unsigned long jresult ;
98622   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98623   std::size_t result;
98624
98625   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98626   {
98627     try {
98628       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
98629     } catch (std::out_of_range& e) {
98630       {
98631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98632       };
98633     } catch (std::exception& e) {
98634       {
98635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98636       };
98637     } catch (Dali::DaliException e) {
98638       {
98639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98640       };
98641     } catch (...) {
98642       {
98643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98644       };
98645     }
98646   }
98647
98648   jresult = (unsigned long)result;
98649   return jresult;
98650 }
98651
98652
98653 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
98654   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98655   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98656
98657   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98658   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98659   {
98660     try {
98661       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
98662     } catch (std::out_of_range& e) {
98663       {
98664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98665       };
98666     } catch (std::exception& e) {
98667       {
98668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98669       };
98670     } catch (Dali::DaliException e) {
98671       {
98672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98673       };
98674     } catch (...) {
98675       {
98676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98677       };
98678     }
98679   }
98680
98681 }
98682
98683
98684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
98685   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98686   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
98687
98688   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98689   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
98690   {
98691     try {
98692       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
98693     } catch (std::out_of_range& e) {
98694       {
98695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98696       };
98697     } catch (std::exception& e) {
98698       {
98699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98700       };
98701     } catch (Dali::DaliException e) {
98702       {
98703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98704       };
98705     } catch (...) {
98706       {
98707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98708       };
98709     }
98710   }
98711
98712 }
98713
98714
98715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
98716   unsigned int jresult ;
98717   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98718   Dali::Toolkit::Slider arg2 ;
98719   int arg3 ;
98720   Dali::Toolkit::Slider *argp2 ;
98721   bool result;
98722
98723   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98724   argp2 = (Dali::Toolkit::Slider *)jarg2;
98725   if (!argp2) {
98726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
98727     return 0;
98728   }
98729   arg2 = *argp2;
98730   arg3 = (int)jarg3;
98731   {
98732     try {
98733       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
98734     } catch (std::out_of_range& e) {
98735       {
98736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98737       };
98738     } catch (std::exception& e) {
98739       {
98740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98741       };
98742     } catch (Dali::DaliException e) {
98743       {
98744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98745       };
98746     } catch (...) {
98747       {
98748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98749       };
98750     }
98751   }
98752
98753   jresult = result;
98754   return jresult;
98755 }
98756
98757
98758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
98759   void * jresult ;
98760   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
98761
98762   {
98763     try {
98764       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
98765     } catch (std::out_of_range& e) {
98766       {
98767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98768       };
98769     } catch (std::exception& e) {
98770       {
98771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98772       };
98773     } catch (Dali::DaliException e) {
98774       {
98775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98776       };
98777     } catch (...) {
98778       {
98779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98780       };
98781     }
98782   }
98783
98784   jresult = (void *)result;
98785   return jresult;
98786 }
98787
98788
98789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
98790   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
98791
98792   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
98793   {
98794     try {
98795       delete arg1;
98796     } catch (std::out_of_range& e) {
98797       {
98798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98799       };
98800     } catch (std::exception& e) {
98801       {
98802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98803       };
98804     } catch (Dali::DaliException e) {
98805       {
98806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98807       };
98808     } catch (...) {
98809       {
98810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98811       };
98812     }
98813   }
98814
98815 }
98816
98817
98818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
98819   void * jresult ;
98820   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98821
98822   {
98823     try {
98824       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
98825     } catch (std::out_of_range& e) {
98826       {
98827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98828       };
98829     } catch (std::exception& e) {
98830       {
98831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98832       };
98833     } catch (Dali::DaliException e) {
98834       {
98835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98836       };
98837     } catch (...) {
98838       {
98839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98840       };
98841     }
98842   }
98843
98844   jresult = (void *)result;
98845   return jresult;
98846 }
98847
98848
98849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
98850   void * jresult ;
98851   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
98852   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98853
98854   arg1 = (Dali::Toolkit::Ruler *)jarg1;
98855   {
98856     try {
98857       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
98858     } catch (std::out_of_range& e) {
98859       {
98860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98861       };
98862     } catch (std::exception& e) {
98863       {
98864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98865       };
98866     } catch (Dali::DaliException e) {
98867       {
98868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98869       };
98870     } catch (...) {
98871       {
98872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98873       };
98874     }
98875   }
98876
98877   jresult = (void *)result;
98878   return jresult;
98879 }
98880
98881
98882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
98883   void * jresult ;
98884   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
98885   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
98886
98887   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98888   if (!arg1) {
98889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
98890     return 0;
98891   }
98892   {
98893     try {
98894       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
98895     } catch (std::out_of_range& e) {
98896       {
98897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98898       };
98899     } catch (std::exception& e) {
98900       {
98901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98902       };
98903     } catch (Dali::DaliException e) {
98904       {
98905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98906       };
98907     } catch (...) {
98908       {
98909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98910       };
98911     }
98912   }
98913
98914   jresult = (void *)result;
98915   return jresult;
98916 }
98917
98918
98919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
98920   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98921
98922   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98923   {
98924     try {
98925       delete arg1;
98926     } catch (std::out_of_range& e) {
98927       {
98928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98929       };
98930     } catch (std::exception& e) {
98931       {
98932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98933       };
98934     } catch (Dali::DaliException e) {
98935       {
98936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98937       };
98938     } catch (...) {
98939       {
98940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98941       };
98942     }
98943   }
98944
98945 }
98946
98947
98948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
98949   void * jresult ;
98950   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98951   Dali::Toolkit::Ruler *result = 0 ;
98952
98953   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98954   {
98955     try {
98956       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
98957     } catch (std::out_of_range& e) {
98958       {
98959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98960       };
98961     } catch (std::exception& e) {
98962       {
98963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98964       };
98965     } catch (Dali::DaliException e) {
98966       {
98967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98968       };
98969     } catch (...) {
98970       {
98971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98972       };
98973     }
98974   }
98975
98976   jresult = (void *)result;
98977   return jresult;
98978 }
98979
98980
98981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
98982   void * jresult ;
98983   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
98984   Dali::Toolkit::Ruler *result = 0 ;
98985
98986   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
98987   {
98988     try {
98989       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
98990     } catch (std::out_of_range& e) {
98991       {
98992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98993       };
98994     } catch (std::exception& e) {
98995       {
98996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98997       };
98998     } catch (Dali::DaliException e) {
98999       {
99000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99001       };
99002     } catch (...) {
99003       {
99004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99005       };
99006     }
99007   }
99008
99009   jresult = (void *)result;
99010   return jresult;
99011 }
99012
99013
99014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
99015   void * jresult ;
99016   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99017   Dali::Toolkit::Ruler *result = 0 ;
99018
99019   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99020   {
99021     try {
99022       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
99023     } catch (std::out_of_range& e) {
99024       {
99025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99026       };
99027     } catch (std::exception& e) {
99028       {
99029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99030       };
99031     } catch (Dali::DaliException e) {
99032       {
99033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99034       };
99035     } catch (...) {
99036       {
99037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99038       };
99039     }
99040   }
99041
99042   jresult = (void *)result;
99043   return jresult;
99044 }
99045
99046
99047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
99048   void * jresult ;
99049   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99050   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
99051   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99052
99053   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99054   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
99055   if (!arg2) {
99056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
99057     return 0;
99058   }
99059   {
99060     try {
99061       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
99062     } catch (std::out_of_range& e) {
99063       {
99064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99065       };
99066     } catch (std::exception& e) {
99067       {
99068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99069       };
99070     } catch (Dali::DaliException e) {
99071       {
99072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99073       };
99074     } catch (...) {
99075       {
99076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99077       };
99078     }
99079   }
99080
99081   jresult = (void *)result;
99082   return jresult;
99083 }
99084
99085
99086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
99087   void * jresult ;
99088   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99089   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99090   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
99091
99092   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99093   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99094   {
99095     try {
99096       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(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_Reset__SWIG_0(void * jarg1) {
99122   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99123
99124   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99125   {
99126     try {
99127       (arg1)->Reset();
99128     } catch (std::out_of_range& e) {
99129       {
99130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99131       };
99132     } catch (std::exception& e) {
99133       {
99134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99135       };
99136     } catch (Dali::DaliException e) {
99137       {
99138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99139       };
99140     } catch (...) {
99141       {
99142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99143       };
99144     }
99145   }
99146
99147 }
99148
99149
99150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
99151   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99152   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
99153
99154   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99155   arg2 = (Dali::Toolkit::Ruler *)jarg2;
99156   {
99157     try {
99158       (arg1)->Reset(arg2);
99159     } catch (std::out_of_range& e) {
99160       {
99161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99162       };
99163     } catch (std::exception& e) {
99164       {
99165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99166       };
99167     } catch (Dali::DaliException e) {
99168       {
99169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99170       };
99171     } catch (...) {
99172       {
99173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99174       };
99175     }
99176   }
99177
99178 }
99179
99180
99181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
99182   void * jresult ;
99183   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99184   Dali::Toolkit::Ruler *result = 0 ;
99185
99186   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99187   {
99188     try {
99189       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
99190     } catch (std::out_of_range& e) {
99191       {
99192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99193       };
99194     } catch (std::exception& e) {
99195       {
99196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99197       };
99198     } catch (Dali::DaliException e) {
99199       {
99200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99201       };
99202     } catch (...) {
99203       {
99204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99205       };
99206     }
99207   }
99208
99209   jresult = (void *)result;
99210   return jresult;
99211 }
99212
99213
99214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
99215   float jresult ;
99216   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99217   float arg2 ;
99218   float arg3 ;
99219   float result;
99220
99221   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99222   arg2 = (float)jarg2;
99223   arg3 = (float)jarg3;
99224   {
99225     try {
99226       result = (float)(*arg1)->Snap(arg2,arg3);
99227     } catch (std::out_of_range& e) {
99228       {
99229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99230       };
99231     } catch (std::exception& e) {
99232       {
99233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99234       };
99235     } catch (Dali::DaliException e) {
99236       {
99237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99238       };
99239     } catch (...) {
99240       {
99241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99242       };
99243     }
99244   }
99245
99246   jresult = result;
99247   return jresult;
99248 }
99249
99250
99251 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
99252   float jresult ;
99253   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99254   float arg2 ;
99255   float result;
99256
99257   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99258   arg2 = (float)jarg2;
99259   {
99260     try {
99261       result = (float)(*arg1)->Snap(arg2);
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_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
99287   float jresult ;
99288   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99289   unsigned int arg2 ;
99290   unsigned int *arg3 = 0 ;
99291   bool arg4 ;
99292   float result;
99293
99294   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99295   arg2 = (unsigned int)jarg2;
99296   arg3 = (unsigned int *)jarg3;
99297   arg4 = jarg4 ? true : false;
99298   {
99299     try {
99300       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
99301     } catch (std::out_of_range& e) {
99302       {
99303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99304       };
99305     } catch (std::exception& e) {
99306       {
99307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99308       };
99309     } catch (Dali::DaliException e) {
99310       {
99311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99312       };
99313     } catch (...) {
99314       {
99315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99316       };
99317     }
99318   }
99319
99320   jresult = result;
99321   return jresult;
99322 }
99323
99324
99325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
99326   unsigned int jresult ;
99327   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99328   float arg2 ;
99329   bool arg3 ;
99330   unsigned int result;
99331
99332   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99333   arg2 = (float)jarg2;
99334   arg3 = jarg3 ? true : false;
99335   {
99336     try {
99337       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
99338     } catch (std::out_of_range& e) {
99339       {
99340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99341       };
99342     } catch (std::exception& e) {
99343       {
99344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99345       };
99346     } catch (Dali::DaliException e) {
99347       {
99348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99349       };
99350     } catch (...) {
99351       {
99352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99353       };
99354     }
99355   }
99356
99357   jresult = result;
99358   return jresult;
99359 }
99360
99361
99362 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
99363   unsigned int jresult ;
99364   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99365   unsigned int result;
99366
99367   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99368   {
99369     try {
99370       result = (unsigned int)(*arg1)->GetTotalPages();
99371     } catch (std::out_of_range& e) {
99372       {
99373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99374       };
99375     } catch (std::exception& e) {
99376       {
99377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99378       };
99379     } catch (Dali::DaliException e) {
99380       {
99381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99382       };
99383     } catch (...) {
99384       {
99385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99386       };
99387     }
99388   }
99389
99390   jresult = result;
99391   return jresult;
99392 }
99393
99394
99395 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
99396   int jresult ;
99397   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99398   Dali::Toolkit::Ruler::RulerType result;
99399
99400   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99401   {
99402     try {
99403       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
99404     } catch (std::out_of_range& e) {
99405       {
99406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99407       };
99408     } catch (std::exception& e) {
99409       {
99410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99411       };
99412     } catch (Dali::DaliException e) {
99413       {
99414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99415       };
99416     } catch (...) {
99417       {
99418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99419       };
99420     }
99421   }
99422
99423   jresult = (int)result;
99424   return jresult;
99425 }
99426
99427
99428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
99429   unsigned int jresult ;
99430   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99431   bool result;
99432
99433   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99434   {
99435     try {
99436       result = (bool)(*arg1)->IsEnabled();
99437     } catch (std::out_of_range& e) {
99438       {
99439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99440       };
99441     } catch (std::exception& e) {
99442       {
99443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99444       };
99445     } catch (Dali::DaliException e) {
99446       {
99447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99448       };
99449     } catch (...) {
99450       {
99451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99452       };
99453     }
99454   }
99455
99456   jresult = result;
99457   return jresult;
99458 }
99459
99460
99461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
99462   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99463
99464   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99465   {
99466     try {
99467       (*arg1)->Enable();
99468     } catch (std::out_of_range& e) {
99469       {
99470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99471       };
99472     } catch (std::exception& e) {
99473       {
99474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99475       };
99476     } catch (Dali::DaliException e) {
99477       {
99478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99479       };
99480     } catch (...) {
99481       {
99482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99483       };
99484     }
99485   }
99486
99487 }
99488
99489
99490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
99491   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99492
99493   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99494   {
99495     try {
99496       (*arg1)->Disable();
99497     } catch (std::out_of_range& e) {
99498       {
99499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99500       };
99501     } catch (std::exception& e) {
99502       {
99503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99504       };
99505     } catch (Dali::DaliException e) {
99506       {
99507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99508       };
99509     } catch (...) {
99510       {
99511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99512       };
99513     }
99514   }
99515
99516 }
99517
99518
99519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
99520   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99521   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
99522   Dali::Toolkit::RulerDomain *argp2 ;
99523
99524   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99525   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
99526   if (!argp2) {
99527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
99528     return ;
99529   }
99530   arg2 = *argp2;
99531   {
99532     try {
99533       (*arg1)->SetDomain(arg2);
99534     } catch (std::out_of_range& e) {
99535       {
99536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99537       };
99538     } catch (std::exception& e) {
99539       {
99540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99541       };
99542     } catch (Dali::DaliException e) {
99543       {
99544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99545       };
99546     } catch (...) {
99547       {
99548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99549       };
99550     }
99551   }
99552
99553 }
99554
99555
99556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
99557   void * jresult ;
99558   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99559   Dali::Toolkit::RulerDomain *result = 0 ;
99560
99561   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99562   {
99563     try {
99564       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
99565     } catch (std::out_of_range& e) {
99566       {
99567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99568       };
99569     } catch (std::exception& e) {
99570       {
99571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99572       };
99573     } catch (Dali::DaliException e) {
99574       {
99575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99576       };
99577     } catch (...) {
99578       {
99579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99580       };
99581     }
99582   }
99583
99584   jresult = (void *)result;
99585   return jresult;
99586 }
99587
99588
99589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
99590   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99591
99592   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99593   {
99594     try {
99595       (*arg1)->DisableDomain();
99596     } catch (std::out_of_range& e) {
99597       {
99598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99599       };
99600     } catch (std::exception& e) {
99601       {
99602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99603       };
99604     } catch (Dali::DaliException e) {
99605       {
99606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99607       };
99608     } catch (...) {
99609       {
99610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99611       };
99612     }
99613   }
99614
99615 }
99616
99617
99618 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
99619   float jresult ;
99620   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99621   float arg2 ;
99622   float arg3 ;
99623   float arg4 ;
99624   float result;
99625
99626   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99627   arg2 = (float)jarg2;
99628   arg3 = (float)jarg3;
99629   arg4 = (float)jarg4;
99630   {
99631     try {
99632       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
99633     } catch (std::out_of_range& e) {
99634       {
99635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99636       };
99637     } catch (std::exception& e) {
99638       {
99639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99640       };
99641     } catch (Dali::DaliException e) {
99642       {
99643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99644       };
99645     } catch (...) {
99646       {
99647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99648       };
99649     }
99650   }
99651
99652   jresult = result;
99653   return jresult;
99654 }
99655
99656
99657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
99658   float jresult ;
99659   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99660   float arg2 ;
99661   float arg3 ;
99662   float result;
99663
99664   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99665   arg2 = (float)jarg2;
99666   arg3 = (float)jarg3;
99667   {
99668     try {
99669       result = (float)(*arg1)->Clamp(arg2,arg3);
99670     } catch (std::out_of_range& e) {
99671       {
99672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99673       };
99674     } catch (std::exception& e) {
99675       {
99676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99677       };
99678     } catch (Dali::DaliException e) {
99679       {
99680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99681       };
99682     } catch (...) {
99683       {
99684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99685       };
99686     }
99687   }
99688
99689   jresult = result;
99690   return jresult;
99691 }
99692
99693
99694 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
99695   float jresult ;
99696   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99697   float arg2 ;
99698   float result;
99699
99700   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99701   arg2 = (float)jarg2;
99702   {
99703     try {
99704       result = (float)(*arg1)->Clamp(arg2);
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_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
99730   float jresult ;
99731   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99732   float arg2 ;
99733   float arg3 ;
99734   float arg4 ;
99735   Dali::Toolkit::ClampState *arg5 = 0 ;
99736   float result;
99737
99738   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99739   arg2 = (float)jarg2;
99740   arg3 = (float)jarg3;
99741   arg4 = (float)jarg4;
99742   arg5 = (Dali::Toolkit::ClampState *)jarg5;
99743   if (!arg5) {
99744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99745     return 0;
99746   }
99747   {
99748     try {
99749       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
99750     } catch (std::out_of_range& e) {
99751       {
99752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99753       };
99754     } catch (std::exception& e) {
99755       {
99756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99757       };
99758     } catch (Dali::DaliException e) {
99759       {
99760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99761       };
99762     } catch (...) {
99763       {
99764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99765       };
99766     }
99767   }
99768
99769   jresult = result;
99770   return jresult;
99771 }
99772
99773
99774 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
99775   float jresult ;
99776   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99777   float arg2 ;
99778   float arg3 ;
99779   float arg4 ;
99780   float arg5 ;
99781   float result;
99782
99783   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99784   arg2 = (float)jarg2;
99785   arg3 = (float)jarg3;
99786   arg4 = (float)jarg4;
99787   arg5 = (float)jarg5;
99788   {
99789     try {
99790       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
99791     } catch (std::out_of_range& e) {
99792       {
99793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99794       };
99795     } catch (std::exception& e) {
99796       {
99797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99798       };
99799     } catch (Dali::DaliException e) {
99800       {
99801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99802       };
99803     } catch (...) {
99804       {
99805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99806       };
99807     }
99808   }
99809
99810   jresult = result;
99811   return jresult;
99812 }
99813
99814
99815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
99816   float jresult ;
99817   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99818   float arg2 ;
99819   float arg3 ;
99820   float arg4 ;
99821   float result;
99822
99823   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99824   arg2 = (float)jarg2;
99825   arg3 = (float)jarg3;
99826   arg4 = (float)jarg4;
99827   {
99828     try {
99829       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
99830     } catch (std::out_of_range& e) {
99831       {
99832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99833       };
99834     } catch (std::exception& e) {
99835       {
99836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99837       };
99838     } catch (Dali::DaliException e) {
99839       {
99840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99841       };
99842     } catch (...) {
99843       {
99844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99845       };
99846     }
99847   }
99848
99849   jresult = result;
99850   return jresult;
99851 }
99852
99853
99854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
99855   float jresult ;
99856   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99857   float arg2 ;
99858   float arg3 ;
99859   float result;
99860
99861   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99862   arg2 = (float)jarg2;
99863   arg3 = (float)jarg3;
99864   {
99865     try {
99866       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
99867     } catch (std::out_of_range& e) {
99868       {
99869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99870       };
99871     } catch (std::exception& e) {
99872       {
99873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99874       };
99875     } catch (Dali::DaliException e) {
99876       {
99877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99878       };
99879     } catch (...) {
99880       {
99881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99882       };
99883     }
99884   }
99885
99886   jresult = result;
99887   return jresult;
99888 }
99889
99890
99891 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
99892   float jresult ;
99893   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99894   float arg2 ;
99895   float result;
99896
99897   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99898   arg2 = (float)jarg2;
99899   {
99900     try {
99901       result = (float)(*arg1)->SnapAndClamp(arg2);
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_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
99927   float jresult ;
99928   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99929   float arg2 ;
99930   float arg3 ;
99931   float arg4 ;
99932   float arg5 ;
99933   Dali::Toolkit::ClampState *arg6 = 0 ;
99934   float result;
99935
99936   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99937   arg2 = (float)jarg2;
99938   arg3 = (float)jarg3;
99939   arg4 = (float)jarg4;
99940   arg5 = (float)jarg5;
99941   arg6 = (Dali::Toolkit::ClampState *)jarg6;
99942   if (!arg6) {
99943     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
99944     return 0;
99945   }
99946   {
99947     try {
99948       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
99949     } catch (std::out_of_range& e) {
99950       {
99951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99952       };
99953     } catch (std::exception& e) {
99954       {
99955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99956       };
99957     } catch (Dali::DaliException e) {
99958       {
99959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99960       };
99961     } catch (...) {
99962       {
99963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99964       };
99965     }
99966   }
99967
99968   jresult = result;
99969   return jresult;
99970 }
99971
99972
99973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
99974   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
99975
99976   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
99977   {
99978     try {
99979       (*arg1)->Reference();
99980     } catch (std::out_of_range& e) {
99981       {
99982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99983       };
99984     } catch (std::exception& e) {
99985       {
99986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99987       };
99988     } catch (Dali::DaliException e) {
99989       {
99990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99991       };
99992     } catch (...) {
99993       {
99994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99995       };
99996     }
99997   }
99998
99999 }
100000
100001
100002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
100003   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100004
100005   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100006   {
100007     try {
100008       (*arg1)->Unreference();
100009     } catch (std::out_of_range& e) {
100010       {
100011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100012       };
100013     } catch (std::exception& e) {
100014       {
100015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100016       };
100017     } catch (Dali::DaliException e) {
100018       {
100019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100020       };
100021     } catch (...) {
100022       {
100023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100024       };
100025     }
100026   }
100027
100028 }
100029
100030
100031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
100032   int jresult ;
100033   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
100034   int result;
100035
100036   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
100037   {
100038     try {
100039       result = (int)(*arg1)->ReferenceCount();
100040     } catch (std::out_of_range& e) {
100041       {
100042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100043       };
100044     } catch (std::exception& e) {
100045       {
100046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100047       };
100048     } catch (Dali::DaliException e) {
100049       {
100050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100051       };
100052     } catch (...) {
100053       {
100054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100055       };
100056     }
100057   }
100058
100059   jresult = result;
100060   return jresult;
100061 }
100062
100063
100064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
100065   unsigned int jresult ;
100066   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100067   bool result;
100068
100069   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100070   {
100071     try {
100072       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100073     } catch (std::out_of_range& e) {
100074       {
100075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100076       };
100077     } catch (std::exception& e) {
100078       {
100079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100080       };
100081     } catch (Dali::DaliException e) {
100082       {
100083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100084       };
100085     } catch (...) {
100086       {
100087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100088       };
100089     }
100090   }
100091
100092   jresult = result;
100093   return jresult;
100094 }
100095
100096
100097 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
100098   unsigned long jresult ;
100099   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100100   std::size_t result;
100101
100102   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100103   {
100104     try {
100105       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
100106     } catch (std::out_of_range& e) {
100107       {
100108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100109       };
100110     } catch (std::exception& e) {
100111       {
100112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100113       };
100114     } catch (Dali::DaliException e) {
100115       {
100116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100117       };
100118     } catch (...) {
100119       {
100120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100121       };
100122     }
100123   }
100124
100125   jresult = (unsigned long)result;
100126   return jresult;
100127 }
100128
100129
100130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
100131   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100132   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100133
100134   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100135   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100136   {
100137     try {
100138       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
100139     } catch (std::out_of_range& e) {
100140       {
100141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100142       };
100143     } catch (std::exception& e) {
100144       {
100145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100146       };
100147     } catch (Dali::DaliException e) {
100148       {
100149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100150       };
100151     } catch (...) {
100152       {
100153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100154       };
100155     }
100156   }
100157
100158 }
100159
100160
100161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
100162   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100163   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
100164
100165   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100166   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
100167   {
100168     try {
100169       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
100170     } catch (std::out_of_range& e) {
100171       {
100172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100173       };
100174     } catch (std::exception& e) {
100175       {
100176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100177       };
100178     } catch (Dali::DaliException e) {
100179       {
100180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100181       };
100182     } catch (...) {
100183       {
100184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100185       };
100186     }
100187   }
100188
100189 }
100190
100191
100192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
100193   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100194   Dali::Toolkit::Control arg2 ;
100195   Dali::Toolkit::Control *argp2 ;
100196
100197   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100198   argp2 = (Dali::Toolkit::Control *)jarg2;
100199   if (!argp2) {
100200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
100201     return ;
100202   }
100203   arg2 = *argp2;
100204   {
100205     try {
100206       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
100207     } catch (std::out_of_range& e) {
100208       {
100209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100210       };
100211     } catch (std::exception& e) {
100212       {
100213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100214       };
100215     } catch (Dali::DaliException e) {
100216       {
100217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100218       };
100219     } catch (...) {
100220       {
100221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100222       };
100223     }
100224   }
100225
100226 }
100227
100228
100229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
100230   void * jresult ;
100231   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
100232
100233   {
100234     try {
100235       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
100236     } catch (std::out_of_range& e) {
100237       {
100238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100239       };
100240     } catch (std::exception& e) {
100241       {
100242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100243       };
100244     } catch (Dali::DaliException e) {
100245       {
100246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100247       };
100248     } catch (...) {
100249       {
100250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100251       };
100252     }
100253   }
100254
100255   jresult = (void *)result;
100256   return jresult;
100257 }
100258
100259
100260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
100261   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
100262
100263   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
100264   {
100265     try {
100266       delete arg1;
100267     } catch (std::out_of_range& e) {
100268       {
100269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100270       };
100271     } catch (std::exception& e) {
100272       {
100273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100274       };
100275     } catch (Dali::DaliException e) {
100276       {
100277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100278       };
100279     } catch (...) {
100280       {
100281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100282       };
100283     }
100284   }
100285
100286 }
100287
100288 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
100289   Dali::RefObject *result = NULL;
100290
100291   if (arg1)
100292   {
100293     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
100294   }
100295   return result;
100296 }
100297
100298 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
100299     return (Dali::RefObject *)jarg1;
100300 }
100301
100302 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
100303     return (Dali::SignalObserver *)jarg1;
100304 }
100305
100306 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
100307     return (Dali::ConnectionTrackerInterface *)jarg1;
100308 }
100309
100310 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
100311     return (Dali::BaseHandle *)jarg1;
100312 }
100313
100314 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
100315     return (Dali::BaseHandle *)jarg1;
100316 }
100317
100318 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
100319     return (Dali::BaseHandle *)jarg1;
100320 }
100321
100322 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
100323     return (Dali::BaseHandle *)jarg1;
100324 }
100325
100326 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
100327     return (Dali::BaseHandle *)jarg1;
100328 }
100329
100330 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
100331     return (Dali::BaseHandle *)jarg1;
100332 }
100333
100334 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
100335     return (Dali::BaseHandle *)jarg1;
100336 }
100337
100338 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
100339     return (Dali::BaseHandle *)jarg1;
100340 }
100341
100342 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
100343     return (Dali::BaseHandle *)jarg1;
100344 }
100345
100346 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
100347     return (Dali::BaseHandle *)jarg1;
100348 }
100349
100350 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
100351     return (Dali::BaseHandle *)jarg1;
100352 }
100353
100354 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
100355     return (Dali::BaseHandle *)jarg1;
100356 }
100357
100358 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
100359     return (Dali::BaseHandle *)jarg1;
100360 }
100361
100362 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
100363     return (Dali::Handle *)jarg1;
100364 }
100365
100366 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
100367     return (Dali::Handle *)jarg1;
100368 }
100369
100370 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
100371     return (Dali::BaseHandle *)jarg1;
100372 }
100373
100374 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
100375     return (Dali::BaseHandle *)jarg1;
100376 }
100377
100378 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
100379     return (Dali::Handle *)jarg1;
100380 }
100381
100382 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
100383     return (Dali::BaseHandle *)jarg1;
100384 }
100385
100386 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
100387     return (Dali::Handle *)jarg1;
100388 }
100389
100390 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
100391     return (Dali::GestureDetector *)jarg1;
100392 }
100393
100394 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
100395     return (Dali::Gesture *)jarg1;
100396 }
100397
100398 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
100399     return (Dali::Handle *)jarg1;
100400 }
100401
100402 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
100403     return (Dali::Actor *)jarg1;
100404 }
100405
100406 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
100407     return (Dali::BaseHandle *)jarg1;
100408 }
100409
100410 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
100411     return (Dali::RefObject *)jarg1;
100412 }
100413
100414 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
100415     return (Dali::Actor *)jarg1;
100416 }
100417
100418 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
100419     return (Dali::GestureDetector *)jarg1;
100420 }
100421
100422 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
100423     return (Dali::Gesture *)jarg1;
100424 }
100425
100426 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
100427     return (Dali::GestureDetector *)jarg1;
100428 }
100429
100430 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
100431     return (Dali::Gesture *)jarg1;
100432 }
100433
100434 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
100435     return (Dali::GestureDetector *)jarg1;
100436 }
100437
100438 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
100439     return (Dali::Gesture *)jarg1;
100440 }
100441
100442 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
100443     return (Dali::BaseHandle *)jarg1;
100444 }
100445
100446 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
100447     return (Dali::Handle *)jarg1;
100448 }
100449
100450 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
100451     return (Dali::Handle *)jarg1;
100452 }
100453
100454 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
100455     return (Dali::Handle *)jarg1;
100456 }
100457
100458 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
100459     return (Dali::Image *)jarg1;
100460 }
100461
100462 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_EncodedBufferImage_SWIGUpcast(Dali::EncodedBufferImage *jarg1) {
100463     return (Dali::Image *)jarg1;
100464 }
100465
100466 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
100467     return (Dali::Image *)jarg1;
100468 }
100469
100470 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
100471     return (Dali::RefObject *)jarg1;
100472 }
100473
100474 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
100475     return (Dali::Image *)jarg1;
100476 }
100477
100478 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_FrameBufferImage_SWIGUpcast(Dali::FrameBufferImage *jarg1) {
100479     return (Dali::Image *)jarg1;
100480 }
100481
100482 SWIGEXPORT Dali::ResourceImage * SWIGSTDCALL CSharp_Dali_NinePatchImage_SWIGUpcast(Dali::NinePatchImage *jarg1) {
100483     return (Dali::ResourceImage *)jarg1;
100484 }
100485
100486 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
100487     return (Dali::Actor *)jarg1;
100488 }
100489
100490 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
100491     return (Dali::BaseHandle *)jarg1;
100492 }
100493
100494 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
100495     return (Dali::BaseHandle *)jarg1;
100496 }
100497
100498 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
100499     return (Dali::BaseHandle *)jarg1;
100500 }
100501
100502 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
100503     return (Dali::CustomActorImpl *)jarg1;
100504 }
100505
100506 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
100507     return (Dali::CustomActor *)jarg1;
100508 }
100509
100510 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
100511     return (Dali::BaseHandle *)jarg1;
100512 }
100513
100514 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
100515     return (Dali::Toolkit::Control *)jarg1;
100516 }
100517
100518 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
100519     return (Dali::Toolkit::Control *)jarg1;
100520 }
100521
100522 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
100523     return (Dali::Toolkit::Button *)jarg1;
100524 }
100525
100526 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
100527     return (Dali::Toolkit::Button *)jarg1;
100528 }
100529
100530 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
100531     return (Dali::Toolkit::Button *)jarg1;
100532 }
100533
100534 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
100535     return (Dali::Toolkit::Control *)jarg1;
100536 }
100537
100538 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
100539     return (Dali::Toolkit::Control *)jarg1;
100540 }
100541
100542 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
100543     return (Dali::Toolkit::Control *)jarg1;
100544 }
100545
100546 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
100547     return (Dali::Toolkit::Control *)jarg1;
100548 }
100549
100550 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
100551     return (Dali::Toolkit::Control *)jarg1;
100552 }
100553
100554 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
100555     return (Dali::RefObject *)jarg1;
100556 }
100557
100558 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
100559     return (Dali::Toolkit::Scrollable *)jarg1;
100560 }
100561
100562 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
100563     return (Dali::BaseHandle *)jarg1;
100564 }
100565
100566 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
100567     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
100568 }
100569
100570 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
100571     return (Dali::RefObject *)jarg1;
100572 }
100573
100574 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
100575     return (Dali::Toolkit::Ruler *)jarg1;
100576 }
100577
100578 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
100579     return (Dali::Toolkit::Ruler *)jarg1;
100580 }
100581
100582 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
100583     return (Dali::Toolkit::Scrollable *)jarg1;
100584 }
100585
100586 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
100587     return (Dali::Toolkit::Control *)jarg1;
100588 }
100589
100590
100591 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
100592     return (Dali::Toolkit::Control *)jarg1;
100593 }
100594
100595 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
100596     return (Dali::BaseHandle *)jarg1;
100597 }
100598
100599 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
100600     return (Dali::BaseHandle *)jarg1;
100601 }
100602
100603 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
100604     return (Dali::Toolkit::Control *)jarg1;
100605 }
100606
100607 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
100608     return (Dali::Toolkit::Control *)jarg1;
100609 }
100610
100611 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
100612     return (Dali::Toolkit::Control *)jarg1;
100613 }
100614
100615 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
100616     return (Dali::Toolkit::Control *)jarg1;
100617 }
100618
100619 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
100620     return (Dali::Toolkit::Control *)jarg1;
100621 }
100622
100623 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
100624     return (Dali::Toolkit::Control *)jarg1;
100625 }
100626
100627 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
100628     return (Dali::Toolkit::PageTurnView *)jarg1;
100629 }
100630
100631 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
100632     return (Dali::Toolkit::PageTurnView *)jarg1;
100633 }
100634
100635 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
100636     return (Dali::Toolkit::Button *)jarg1;
100637 }
100638
100639 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
100640     return (Dali::BaseHandle *)jarg1;
100641 }
100642
100643 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
100644     return (Dali::BaseHandle *)jarg1;
100645 }
100646
100647 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
100648     return (Dali::BaseHandle *)jarg1;
100649 }
100650
100651 /*
100652  * Widget binding
100653  */
100654 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
100655     return (Dali::BaseHandle *)jarg1;
100656 }
100657
100658 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
100659     return (Dali::BaseObject *)jarg1;
100660 }
100661
100662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
100663   void * jresult ;
100664   Dali::Widget result;
100665
100666   {
100667     try {
100668       result = Dali::Widget::New();
100669     } catch (std::out_of_range& e) {
100670       {
100671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100672       };
100673     } catch (std::exception& e) {
100674       {
100675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100676       };
100677     } catch (...) {
100678       {
100679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100680       };
100681     }
100682   }
100683   jresult = new Dali::Widget((const Dali::Widget &)result);
100684   return jresult;
100685 }
100686
100687
100688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
100689   void * jresult ;
100690   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
100691   Dali::Widget result;
100692
100693   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100694
100695   if (!arg1) {
100696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
100697     return 0;
100698   }
100699   {
100700     try {
100701       jresult = new Dali::Widget(arg1);
100702     } catch (std::out_of_range& e) {
100703       {
100704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100705       };
100706     } catch (std::exception& e) {
100707       {
100708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100709       };
100710     } catch (...) {
100711       {
100712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100713       };
100714     }
100715   }
100716   return jresult;
100717 }
100718
100719
100720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
100721   void * jresult ;
100722   Dali::Widget *result = 0 ;
100723
100724   {
100725     try {
100726       result = (Dali::Widget *)new Dali::Widget();
100727     } catch (std::out_of_range& e) {
100728       {
100729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100730       };
100731     } catch (std::exception& e) {
100732       {
100733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100734       };
100735     } catch (...) {
100736       {
100737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100738       };
100739     }
100740   }
100741   jresult = (void *)result;
100742   return jresult;
100743 }
100744
100745
100746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
100747   void * jresult ;
100748   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100749   Dali::Widget *arg2 = 0 ;
100750   Dali::Widget *result = 0 ;
100751
100752   arg1 = (Dali::Widget *)jarg1;
100753   arg2 = (Dali::Widget *)jarg2;
100754   if (!arg2) {
100755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
100756     return 0;
100757   }
100758   {
100759     try {
100760       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
100761     } catch (std::out_of_range& e) {
100762       {
100763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100764       };
100765     } catch (std::exception& e) {
100766       {
100767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100768       };
100769     } catch (...) {
100770       {
100771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100772       };
100773     }
100774   }
100775   jresult = (void *)result;
100776   return jresult;
100777 }
100778
100779
100780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
100781   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
100782
100783   arg1 = (Dali::Widget *)jarg1;
100784   {
100785     try {
100786       delete arg1;
100787     } catch (std::out_of_range& e) {
100788       {
100789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100790       };
100791     } catch (std::exception& e) {
100792       {
100793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100794       };
100795     } catch (...) {
100796       {
100797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100798       };
100799     }
100800   }
100801 }
100802
100803
100804 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
100805   void * jresult ;
100806   SwigDirector_WidgetImpl* result;
100807   {
100808     try {
100809       result = new SwigDirector_WidgetImpl();
100810     } catch (std::out_of_range& e) {
100811       {
100812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100813       };
100814     } catch (std::exception& e) {
100815       {
100816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100817       };
100818     } catch (...) {
100819       {
100820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100821       };
100822     }
100823   }
100824   jresult = result;
100825   return jresult;
100826 }
100827
100828
100829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
100830   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100831   std::string *arg2 = 0 ;
100832   Dali::Window arg3 ;
100833   Dali::Window *argp3 ;
100834
100835   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100836   if (!jarg2) {
100837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100838     return ;
100839   }
100840   std::string arg2_str(jarg2);
100841   arg2 = &arg2_str;
100842   argp3 = (Dali::Window *)jarg3;
100843   if (!argp3) {
100844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100845     return ;
100846   }
100847   arg3 = *argp3;
100848   {
100849     try {
100850       (arg1)->OnCreate((std::string const &)*arg2,arg3);
100851     } catch (std::out_of_range& e) {
100852       {
100853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100854       };
100855     } catch (std::exception& e) {
100856       {
100857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100858       };
100859     } catch (...) {
100860       {
100861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100862       };
100863     }
100864   }
100865 }
100866
100867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
100868   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100869   std::string *arg2 = 0 ;
100870   Dali::Window arg3 ;
100871   Dali::Window *argp3 ;
100872
100873   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100874   if (!jarg2) {
100875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100876     return ;
100877   }
100878   std::string arg2_str(jarg2);
100879   arg2 = &arg2_str;
100880   argp3 = (Dali::Window *)jarg3;
100881   if (!argp3) {
100882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
100883     return ;
100884   }
100885   arg3 = *argp3;
100886   {
100887     try {
100888       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
100889     } catch (std::out_of_range& e) {
100890       {
100891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100892       };
100893     } catch (std::exception& e) {
100894       {
100895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100896       };
100897     } catch (...) {
100898       {
100899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100900       };
100901     }
100902   }
100903 }
100904
100905
100906 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
100907   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100908   std::string *arg2 = 0 ;
100909   Dali::Widget::Termination arg3 ;
100910
100911   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100912   if (!jarg2) {
100913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100914     return ;
100915   }
100916   std::string arg2_str(jarg2);
100917   arg2 = &arg2_str;
100918   arg3 = (Dali::Widget::Termination)jarg3;
100919   {
100920     try {
100921       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
100922     } catch (std::out_of_range& e) {
100923       {
100924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100925       };
100926     } catch (std::exception& e) {
100927       {
100928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100929       };
100930     } catch (...) {
100931       {
100932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100933       };
100934     }
100935   }
100936 }
100937
100938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
100939   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100940   std::string *arg2 = 0 ;
100941   Dali::Widget::Termination arg3 ;
100942
100943   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100944   if (!jarg2) {
100945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100946     return ;
100947   }
100948   std::string arg2_str(jarg2);
100949   arg2 = &arg2_str;
100950   arg3 = (Dali::Widget::Termination)jarg3;
100951   {
100952     try {
100953       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
100954     } catch (std::out_of_range& e) {
100955       {
100956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100957       };
100958     } catch (std::exception& e) {
100959       {
100960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100961       };
100962     } catch (...) {
100963       {
100964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100965       };
100966     }
100967   }
100968 }
100969
100970
100971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
100972   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100973
100974   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100975   {
100976     try {
100977       (arg1)->OnPause();
100978     } catch (std::out_of_range& e) {
100979       {
100980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100981       };
100982     } catch (std::exception& e) {
100983       {
100984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100985       };
100986     } catch (...) {
100987       {
100988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100989       };
100990     }
100991   }
100992 }
100993
100994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
100995   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
100996
100997   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
100998   {
100999     try {
101000       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
101001     } catch (std::out_of_range& e) {
101002       {
101003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101004       };
101005     } catch (std::exception& e) {
101006       {
101007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101008       };
101009     } catch (...) {
101010       {
101011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101012       };
101013     }
101014   }
101015 }
101016
101017
101018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
101019   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101020
101021   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101022   {
101023     try {
101024       (arg1)->OnResume();
101025     } catch (std::out_of_range& e) {
101026       {
101027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101028       };
101029     } catch (std::exception& e) {
101030       {
101031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101032       };
101033     } catch (...) {
101034       {
101035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101036       };
101037     }
101038   }
101039 }
101040
101041
101042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
101043   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101044
101045   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101046   {
101047     try {
101048       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
101049     } catch (std::out_of_range& e) {
101050       {
101051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101052       };
101053     } catch (std::exception& e) {
101054       {
101055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101056       };
101057     } catch (...) {
101058       {
101059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101060       };
101061     }
101062   }
101063 }
101064
101065
101066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
101067   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101068   Dali::Window arg2 ;
101069   Dali::Window *argp2 ;
101070
101071   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101072   argp2 = (Dali::Window *)jarg2;
101073   if (!argp2) {
101074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101075     return ;
101076   }
101077   arg2 = *argp2;
101078   {
101079     try {
101080       (arg1)->OnResize(arg2);
101081     } catch (std::out_of_range& e) {
101082       {
101083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101084       };
101085     } catch (std::exception& e) {
101086       {
101087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101088       };
101089     } catch (...) {
101090       {
101091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101092       };
101093     }
101094   }
101095 }
101096
101097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
101098   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101099   Dali::Window arg2 ;
101100   Dali::Window *argp2 ;
101101
101102   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101103   argp2 = (Dali::Window *)jarg2;
101104   if (!argp2) {
101105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
101106     return ;
101107   }
101108   arg2 = *argp2;
101109   {
101110     try {
101111       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
101112     } catch (std::out_of_range& e) {
101113       {
101114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101115       };
101116     } catch (std::exception& e) {
101117       {
101118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101119       };
101120     } catch (...) {
101121       {
101122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101123       };
101124     }
101125   }
101126 }
101127
101128
101129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
101130   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101131   std::string *arg2 = 0 ;
101132   int arg3 ;
101133
101134   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101135   if (!jarg2) {
101136     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101137     return ;
101138   }
101139   std::string arg2_str(jarg2);
101140   arg2 = &arg2_str;
101141   arg3 = (int)jarg3;
101142   {
101143     try {
101144       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
101145     } catch (std::out_of_range& e) {
101146       {
101147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101148       };
101149     } catch (std::exception& e) {
101150       {
101151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101152       };
101153     } catch (...) {
101154       {
101155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101156       };
101157     }
101158   }
101159 }
101160
101161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
101162   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101163   std::string *arg2 = 0 ;
101164   int arg3 ;
101165
101166   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101167   if (!jarg2) {
101168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101169     return ;
101170   }
101171   std::string arg2_str(jarg2);
101172   arg2 = &arg2_str;
101173   arg3 = (int)jarg3;
101174   {
101175     try {
101176       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
101177     } catch (std::out_of_range& e) {
101178       {
101179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101180       };
101181     } catch (std::exception& e) {
101182       {
101183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101184       };
101185     } catch (...) {
101186       {
101187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101188       };
101189     }
101190   }
101191 }
101192
101193
101194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
101195   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101196   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101197   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101198
101199   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101200   arg2 = (Dali::SlotObserver *)jarg2;
101201   arg3 = (Dali::CallbackBase *)jarg3;
101202   {
101203     try {
101204       (arg1)->SignalConnected(arg2,arg3);
101205     } catch (std::out_of_range& e) {
101206       {
101207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101208       };
101209     } catch (std::exception& e) {
101210       {
101211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101212       };
101213     } catch (...) {
101214       {
101215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101216       };
101217     }
101218   }
101219 }
101220
101221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101222   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101223   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101224   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101225
101226   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101227   arg2 = (Dali::SlotObserver *)jarg2;
101228   arg3 = (Dali::CallbackBase *)jarg3;
101229   {
101230     try {
101231       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
101232     } catch (std::out_of_range& e) {
101233       {
101234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101235       };
101236     } catch (std::exception& e) {
101237       {
101238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101239       };
101240     } catch (...) {
101241       {
101242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101243       };
101244     }
101245   }
101246 }
101247
101248
101249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
101250   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101251   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101252   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101253
101254   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101255   arg2 = (Dali::SlotObserver *)jarg2;
101256   arg3 = (Dali::CallbackBase *)jarg3;
101257   {
101258     try {
101259       (arg1)->SignalDisconnected(arg2,arg3);
101260     } catch (std::out_of_range& e) {
101261       {
101262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101263       };
101264     } catch (std::exception& e) {
101265       {
101266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101267       };
101268     } catch (...) {
101269       {
101270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101271       };
101272     }
101273   }
101274 }
101275
101276 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
101277   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101278   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
101279   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
101280
101281   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101282   arg2 = (Dali::SlotObserver *)jarg2;
101283   arg3 = (Dali::CallbackBase *)jarg3;
101284   {
101285     try {
101286       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
101287     } catch (std::out_of_range& e) {
101288       {
101289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101290       };
101291     } catch (std::exception& e) {
101292       {
101293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101294       };
101295     } catch (...) {
101296       {
101297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101298       };
101299     }
101300   }
101301 }
101302
101303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
101304   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101305   std::string *arg2 = 0 ;
101306
101307   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101308   if (!jarg2) {
101309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101310     return ;
101311   }
101312   std::string arg2_str(jarg2);
101313   arg2 = &arg2_str;
101314   {
101315     try {
101316       (arg1)->SetContentInfo((std::string const &)*arg2);
101317     } catch (std::out_of_range& e) {
101318       {
101319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101320       };
101321     } catch (std::exception& e) {
101322       {
101323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101324       };
101325     } catch (...) {
101326       {
101327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101328       };
101329     }
101330   }
101331 }
101332
101333
101334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
101335   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
101336   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
101337
101338   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
101339   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
101340   {
101341     try {
101342       (arg1)->SetImpl(arg2);
101343     } catch (std::out_of_range& e) {
101344       {
101345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101346       };
101347     } catch (std::exception& e) {
101348       {
101349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101350       };
101351     } catch (...) {
101352       {
101353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101354       };
101355     }
101356   }
101357 }
101358
101359 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) {
101360
101361   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
101362   if (director) {
101363     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
101364   }
101365 }
101366
101367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
101368   void * jresult ;
101369   Dali::Widget *arg1 = 0 ;
101370   SwigDirector_WidgetImpl *result = 0 ;
101371
101372   arg1 = (Dali::Widget *)jarg1;
101373   if (!arg1) {
101374     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
101375     return 0;
101376   }
101377   {
101378     try {
101379       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
101380     } catch (std::out_of_range& e) {
101381       {
101382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101383       };
101384     } catch (std::exception& e) {
101385       {
101386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101387       };
101388     } catch (...) {
101389       {
101390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101391       };
101392     }
101393   }
101394
101395   jresult = (void *)result;
101396   return jresult;
101397 }
101398
101399
101400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
101401   void * jresult ;
101402   int *arg1 = (int *) 0 ;
101403   char ***arg2 ;
101404   std::string *arg3 = 0 ;
101405   Dali::WidgetApplication result;
101406   {
101407     int index = 0;
101408     int length = 0;
101409     char *retPtr;
101410     char *nextPtr;
101411     argWidgetC = jarg1;
101412     argWidgetV = new char*[jarg1 + 1];
101413
101414     retPtr = strtok_r( jarg2, " ", &nextPtr);
101415     if( retPtr )
101416     {
101417       length = strlen(retPtr);
101418     }
101419     argWidgetV[index] = new char[length + 1];
101420     if( retPtr )
101421     {
101422       strncpy(argWidgetV[index], retPtr, length);
101423     }
101424     argWidgetV[index][length] = '\0';
101425     index++;
101426
101427     while (index < jarg1)
101428     {
101429       length = 0;
101430       retPtr = strtok_r(NULL, " ", &nextPtr);
101431       if( retPtr )
101432       {
101433         length = strlen(retPtr);
101434       }
101435       argWidgetV[index] = new char[length + 1];
101436       if( retPtr )
101437       {
101438         strncpy(argWidgetV[index], retPtr, length);
101439       }
101440       argWidgetV[index][length] = '\0';
101441       index++;
101442     }
101443
101444     argWidgetV[jarg1] = NULL;
101445     argWidgetC = jarg1;
101446
101447     arg1 = &argWidgetC;
101448     arg2 = &argWidgetV;
101449   }
101450
101451   if (!jarg3) {
101452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101453     return 0;
101454   }
101455   std::string arg3_str(jarg3);
101456   arg3 = &arg3_str;
101457   {
101458     try {
101459       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
101460     } catch (std::out_of_range& e) {
101461       {
101462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101463       };
101464     } catch (std::exception& e) {
101465       {
101466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101467       };
101468     } catch (...) {
101469       {
101470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101471       };
101472     }
101473   }
101474   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
101475
101476   return jresult;
101477 }
101478
101479
101480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
101481   void * jresult ;
101482   Dali::WidgetApplication *result = 0 ;
101483
101484   {
101485     try {
101486       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
101487     } catch (std::out_of_range& e) {
101488       {
101489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101490       };
101491     } catch (std::exception& e) {
101492       {
101493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101494       };
101495     } catch (...) {
101496       {
101497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101498       };
101499     }
101500   }
101501   jresult = (void *)result;
101502   return jresult;
101503 }
101504
101505
101506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
101507   void * jresult ;
101508   Dali::WidgetApplication *arg1 = 0 ;
101509   Dali::WidgetApplication *result = 0 ;
101510
101511   arg1 = (Dali::WidgetApplication *)jarg1;
101512   if (!arg1) {
101513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101514     return 0;
101515   }
101516   {
101517     try {
101518       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
101519     } catch (std::out_of_range& e) {
101520       {
101521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101522       };
101523     } catch (std::exception& e) {
101524       {
101525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101526       };
101527     } catch (...) {
101528       {
101529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101530       };
101531     }
101532   }
101533   jresult = (void *)result;
101534   return jresult;
101535 }
101536
101537
101538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
101539   void * jresult ;
101540   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101541   Dali::WidgetApplication *arg2 = 0 ;
101542   Dali::WidgetApplication *result = 0 ;
101543
101544   arg1 = (Dali::WidgetApplication *)jarg1;
101545   arg2 = (Dali::WidgetApplication *)jarg2;
101546   if (!arg2) {
101547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
101548     return 0;
101549   }
101550   {
101551     try {
101552       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
101553     } catch (std::out_of_range& e) {
101554       {
101555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101556       };
101557     } catch (std::exception& e) {
101558       {
101559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101560       };
101561     } catch (...) {
101562       {
101563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101564       };
101565     }
101566   }
101567   jresult = (void *)result;
101568   return jresult;
101569 }
101570
101571
101572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
101573   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101574
101575   arg1 = (Dali::WidgetApplication *)jarg1;
101576   {
101577     try {
101578       delete arg1;
101579       if( argWidgetV )
101580       {
101581         // free string data
101582         for( int i=0; i < argWidgetC+1; i++)
101583         {
101584           delete [] argWidgetV[i];
101585         }
101586         delete [] argWidgetV;
101587       }
101588     } catch (std::out_of_range& e) {
101589       {
101590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101591       };
101592     } catch (std::exception& e) {
101593       {
101594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101595       };
101596     } catch (...) {
101597       {
101598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101599       };
101600     }
101601   }
101602 }
101603
101604
101605 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
101606 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
101607
101608 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
101609 {
101610   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
101611   return *widget;
101612 }
101613
101614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
101615   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
101616   std::string *arg2 = 0 ;
101617
101618   arg1 = (Dali::WidgetApplication *)jarg1;
101619   if (!jarg2) {
101620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101621     return ;
101622   }
101623   std::string arg2_str(*jarg2);
101624   arg2 = &arg2_str;
101625
101626   if(!_CSharpCreateWidgetFunction)
101627   {
101628     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
101629   }
101630
101631   {
101632     try {
101633       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
101634     } catch (std::out_of_range& e) {
101635       {
101636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101637       };
101638     } catch (std::exception& e) {
101639       {
101640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101641       };
101642     } catch (...) {
101643       {
101644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101645       };
101646     }
101647   }
101648
101649   //Typemap argout in c++ file.
101650   //This will convert c++ string to c# string
101651   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
101652 }
101653
101654
101655 //for PixelBuffer and ImageLoading
101656
101657 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
101658     return (Dali::BaseHandle *)jarg1;
101659 }
101660
101661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
101662   void * jresult ;
101663   unsigned int arg1 ;
101664   unsigned int arg2 ;
101665   Dali::Pixel::Format arg3 ;
101666   Dali::Devel::PixelBuffer result;
101667
101668   arg1 = (unsigned int)jarg1;
101669   arg2 = (unsigned int)jarg2;
101670   arg3 = (Dali::Pixel::Format)jarg3;
101671   {
101672     try {
101673       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
101674     } catch (std::out_of_range& e) {
101675       {
101676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101677       };
101678     } catch (std::exception& e) {
101679       {
101680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101681       };
101682     } catch (...) {
101683       {
101684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101685       };
101686     }
101687   }
101688   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
101689   return jresult;
101690 }
101691
101692
101693 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
101694   void * jresult ;
101695   Dali::Devel::PixelBuffer *result = 0 ;
101696
101697   {
101698     try {
101699       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
101700     } catch (std::out_of_range& e) {
101701       {
101702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101703       };
101704     } catch (std::exception& e) {
101705       {
101706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101707       };
101708     } catch (...) {
101709       {
101710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101711       };
101712     }
101713   }
101714   jresult = (void *)result;
101715   return jresult;
101716 }
101717
101718
101719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
101720   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101721
101722   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101723   {
101724     try {
101725       delete arg1;
101726     } catch (std::out_of_range& e) {
101727       {
101728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101729       };
101730     } catch (std::exception& e) {
101731       {
101732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101733       };
101734     } catch (...) {
101735       {
101736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101737       };
101738     }
101739   }
101740 }
101741
101742
101743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
101744   void * jresult ;
101745   Dali::Devel::PixelBuffer *arg1 = 0 ;
101746   Dali::Devel::PixelBuffer *result = 0 ;
101747
101748   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101749   if (!arg1) {
101750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101751     return 0;
101752   }
101753   {
101754     try {
101755       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
101756     } catch (std::out_of_range& e) {
101757       {
101758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101759       };
101760     } catch (std::exception& e) {
101761       {
101762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101763       };
101764     } catch (...) {
101765       {
101766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101767       };
101768     }
101769   }
101770   jresult = (void *)result;
101771   return jresult;
101772 }
101773
101774
101775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
101776   void * jresult ;
101777   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101778   Dali::Devel::PixelBuffer *arg2 = 0 ;
101779   Dali::Devel::PixelBuffer *result = 0 ;
101780
101781   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101782   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
101783   if (!arg2) {
101784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
101785     return 0;
101786   }
101787   {
101788     try {
101789       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
101790     } catch (std::out_of_range& e) {
101791       {
101792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101793       };
101794     } catch (std::exception& e) {
101795       {
101796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101797       };
101798     } catch (...) {
101799       {
101800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101801       };
101802     }
101803   }
101804   jresult = (void *)result;
101805   return jresult;
101806 }
101807
101808
101809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
101810   void * jresult ;
101811   Dali::Devel::PixelBuffer *arg1 = 0 ;
101812   Dali::PixelData result;
101813
101814   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101815   if (!arg1) {
101816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
101817     return 0;
101818   }
101819   {
101820     try {
101821       result = Dali::Devel::PixelBuffer::Convert(*arg1);
101822     } catch (std::out_of_range& e) {
101823       {
101824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101825       };
101826     } catch (std::exception& e) {
101827       {
101828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101829       };
101830     } catch (...) {
101831       {
101832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101833       };
101834     }
101835   }
101836   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101837   return jresult;
101838 }
101839
101840
101841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
101842   void * jresult ;
101843   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101844   Dali::PixelData result;
101845
101846   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101847   {
101848     try {
101849       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
101850     } catch (std::out_of_range& e) {
101851       {
101852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101853       };
101854     } catch (std::exception& e) {
101855       {
101856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101857       };
101858     } catch (...) {
101859       {
101860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101861       };
101862     }
101863   }
101864   jresult = new Dali::PixelData((const Dali::PixelData &)result);
101865   return jresult;
101866 }
101867
101868
101869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
101870   void * jresult ;
101871   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101872   unsigned char *result = 0 ;
101873
101874   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101875   {
101876     try {
101877       result = (unsigned char *)(arg1)->GetBuffer();
101878     } catch (std::out_of_range& e) {
101879       {
101880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101881       };
101882     } catch (std::exception& e) {
101883       {
101884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101885       };
101886     } catch (...) {
101887       {
101888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101889       };
101890     }
101891   }
101892   jresult = (void *)result;
101893   return jresult;
101894 }
101895
101896
101897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
101898   unsigned int jresult ;
101899   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101900   unsigned int result;
101901
101902   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101903   {
101904     try {
101905       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
101906     } catch (std::out_of_range& e) {
101907       {
101908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101909       };
101910     } catch (std::exception& e) {
101911       {
101912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101913       };
101914     } catch (...) {
101915       {
101916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101917       };
101918     }
101919   }
101920   jresult = result;
101921   return jresult;
101922 }
101923
101924
101925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
101926   unsigned int jresult ;
101927   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101928   unsigned int result;
101929
101930   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101931   {
101932     try {
101933       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
101934     } catch (std::out_of_range& e) {
101935       {
101936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101937       };
101938     } catch (std::exception& e) {
101939       {
101940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101941       };
101942     } catch (...) {
101943       {
101944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101945       };
101946     }
101947   }
101948   jresult = result;
101949   return jresult;
101950 }
101951
101952
101953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
101954   int jresult ;
101955   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101956   Dali::Pixel::Format result;
101957
101958   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101959   {
101960     try {
101961       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
101962     } catch (std::out_of_range& e) {
101963       {
101964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101965       };
101966     } catch (std::exception& e) {
101967       {
101968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101969       };
101970     } catch (...) {
101971       {
101972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101973       };
101974     }
101975   }
101976   jresult = (int)result;
101977   return jresult;
101978 }
101979
101980
101981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
101982   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
101983   Dali::Devel::PixelBuffer arg2 ;
101984   float arg3 ;
101985   bool arg4 ;
101986   Dali::Devel::PixelBuffer *argp2 ;
101987
101988   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
101989   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
101990   if (!argp2) {
101991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
101992     return ;
101993   }
101994   arg2 = *argp2;
101995   arg3 = (float)jarg3;
101996   arg4 = jarg4 ? true : false;
101997   {
101998     try {
101999       (arg1)->ApplyMask(arg2,arg3,arg4);
102000     } catch (std::out_of_range& e) {
102001       {
102002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102003       };
102004     } catch (std::exception& e) {
102005       {
102006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102007       };
102008     } catch (...) {
102009       {
102010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102011       };
102012     }
102013   }
102014 }
102015
102016
102017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
102018   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102019   Dali::Devel::PixelBuffer arg2 ;
102020   float arg3 ;
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   {
102032     try {
102033       (arg1)->ApplyMask(arg2,arg3);
102034     } catch (std::out_of_range& e) {
102035       {
102036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102037       };
102038     } catch (std::exception& e) {
102039       {
102040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102041       };
102042     } catch (...) {
102043       {
102044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102045       };
102046     }
102047   }
102048 }
102049
102050
102051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
102052   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102053   Dali::Devel::PixelBuffer arg2 ;
102054   Dali::Devel::PixelBuffer *argp2 ;
102055
102056   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102057   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
102058   if (!argp2) {
102059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
102060     return ;
102061   }
102062   arg2 = *argp2;
102063   {
102064     try {
102065       (arg1)->ApplyMask(arg2);
102066     } catch (std::out_of_range& e) {
102067       {
102068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102069       };
102070     } catch (std::exception& e) {
102071       {
102072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102073       };
102074     } catch (...) {
102075       {
102076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102077       };
102078     }
102079   }
102080 }
102081
102082
102083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
102084   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102085   float arg2 ;
102086
102087   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102088   arg2 = (float)jarg2;
102089   {
102090     try {
102091       (arg1)->ApplyGaussianBlur(arg2);
102092     } catch (std::out_of_range& e) {
102093       {
102094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102095       };
102096     } catch (std::exception& e) {
102097       {
102098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102099       };
102100     } catch (...) {
102101       {
102102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102103       };
102104     }
102105   }
102106 }
102107
102108
102109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
102110   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102111   uint16_t arg2 ;
102112   uint16_t arg3 ;
102113   uint16_t arg4 ;
102114   uint16_t arg5 ;
102115
102116   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102117   arg2 = (uint16_t)jarg2;
102118   arg3 = (uint16_t)jarg3;
102119   arg4 = (uint16_t)jarg4;
102120   arg5 = (uint16_t)jarg5;
102121   {
102122     try {
102123       (arg1)->Crop(arg2,arg3,arg4,arg5);
102124     } catch (std::out_of_range& e) {
102125       {
102126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102127       };
102128     } catch (std::exception& e) {
102129       {
102130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102131       };
102132     } catch (...) {
102133       {
102134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102135       };
102136     }
102137   }
102138 }
102139
102140
102141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
102142   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
102143   uint16_t arg2 ;
102144   uint16_t arg3 ;
102145
102146   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
102147   arg2 = (uint16_t)jarg2;
102148   arg3 = (uint16_t)jarg3;
102149   {
102150     try {
102151       (arg1)->Resize(arg2,arg3);
102152     } catch (std::out_of_range& e) {
102153       {
102154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102155       };
102156     } catch (std::exception& e) {
102157       {
102158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102159       };
102160     } catch (...) {
102161       {
102162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102163       };
102164     }
102165   }
102166 }
102167
102168
102169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102170   void * jresult ;
102171   std::string *arg1 = 0 ;
102172   Dali::ImageDimensions arg2 ;
102173   Dali::FittingMode::Type arg3 ;
102174   Dali::SamplingMode::Type arg4 ;
102175   bool arg5 ;
102176   Dali::ImageDimensions *argp2 ;
102177   Dali::Devel::PixelBuffer result;
102178
102179   if (!jarg1) {
102180     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102181     return 0;
102182   }
102183   std::string arg1_str(jarg1);
102184   arg1 = &arg1_str;
102185   argp2 = (Dali::ImageDimensions *)jarg2;
102186   if (!argp2) {
102187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102188     return 0;
102189   }
102190   arg2 = *argp2;
102191   arg3 = (Dali::FittingMode::Type)jarg3;
102192   arg4 = (Dali::SamplingMode::Type)jarg4;
102193   arg5 = jarg5 ? true : false;
102194   {
102195     try {
102196       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102197     } catch (std::out_of_range& e) {
102198       {
102199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102200       };
102201     } catch (std::exception& e) {
102202       {
102203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102204       };
102205     } catch (...) {
102206       {
102207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102208       };
102209     }
102210   }
102211   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102212
102213   return jresult;
102214 }
102215
102216
102217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102218   void * jresult ;
102219   std::string *arg1 = 0 ;
102220   Dali::ImageDimensions arg2 ;
102221   Dali::FittingMode::Type arg3 ;
102222   Dali::SamplingMode::Type arg4 ;
102223   Dali::ImageDimensions *argp2 ;
102224   Dali::Devel::PixelBuffer result;
102225
102226   if (!jarg1) {
102227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102228     return 0;
102229   }
102230   std::string arg1_str(jarg1);
102231   arg1 = &arg1_str;
102232   argp2 = (Dali::ImageDimensions *)jarg2;
102233   if (!argp2) {
102234     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102235     return 0;
102236   }
102237   arg2 = *argp2;
102238   arg3 = (Dali::FittingMode::Type)jarg3;
102239   arg4 = (Dali::SamplingMode::Type)jarg4;
102240   {
102241     try {
102242       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
102243     } catch (std::out_of_range& e) {
102244       {
102245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102246       };
102247     } catch (std::exception& e) {
102248       {
102249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102250       };
102251     } catch (...) {
102252       {
102253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102254       };
102255     }
102256   }
102257   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102258
102259   return jresult;
102260 }
102261
102262
102263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102264   void * jresult ;
102265   std::string *arg1 = 0 ;
102266   Dali::ImageDimensions arg2 ;
102267   Dali::FittingMode::Type arg3 ;
102268   Dali::ImageDimensions *argp2 ;
102269   Dali::Devel::PixelBuffer result;
102270
102271   if (!jarg1) {
102272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102273     return 0;
102274   }
102275   std::string arg1_str(jarg1);
102276   arg1 = &arg1_str;
102277   argp2 = (Dali::ImageDimensions *)jarg2;
102278   if (!argp2) {
102279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102280     return 0;
102281   }
102282   arg2 = *argp2;
102283   arg3 = (Dali::FittingMode::Type)jarg3;
102284   {
102285     try {
102286       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
102287     } catch (std::out_of_range& e) {
102288       {
102289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102290       };
102291     } catch (std::exception& e) {
102292       {
102293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102294       };
102295     } catch (...) {
102296       {
102297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102298       };
102299     }
102300   }
102301   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102302
102303   return jresult;
102304 }
102305
102306
102307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
102308   void * jresult ;
102309   std::string *arg1 = 0 ;
102310   Dali::ImageDimensions arg2 ;
102311   Dali::ImageDimensions *argp2 ;
102312   Dali::Devel::PixelBuffer result;
102313
102314   if (!jarg1) {
102315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102316     return 0;
102317   }
102318   std::string arg1_str(jarg1);
102319   arg1 = &arg1_str;
102320   argp2 = (Dali::ImageDimensions *)jarg2;
102321   if (!argp2) {
102322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102323     return 0;
102324   }
102325   arg2 = *argp2;
102326   {
102327     try {
102328       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
102329     } catch (std::out_of_range& e) {
102330       {
102331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102332       };
102333     } catch (std::exception& e) {
102334       {
102335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102336       };
102337     } catch (...) {
102338       {
102339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102340       };
102341     }
102342   }
102343   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102344
102345   return jresult;
102346 }
102347
102348
102349 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
102350   void * jresult ;
102351   std::string *arg1 = 0 ;
102352   Dali::Devel::PixelBuffer result;
102353
102354   if (!jarg1) {
102355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102356     return 0;
102357   }
102358   std::string arg1_str(jarg1);
102359   arg1 = &arg1_str;
102360   {
102361     try {
102362       result = Dali::LoadImageFromFile((std::string const &)*arg1);
102363     } catch (std::out_of_range& e) {
102364       {
102365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102366       };
102367     } catch (std::exception& e) {
102368       {
102369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102370       };
102371     } catch (...) {
102372       {
102373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102374       };
102375     }
102376   }
102377   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102378
102379   return jresult;
102380 }
102381
102382
102383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102384   void * jresult ;
102385   std::string *arg1 = 0 ;
102386   Dali::ImageDimensions arg2 ;
102387   Dali::FittingMode::Type arg3 ;
102388   Dali::SamplingMode::Type arg4 ;
102389   bool arg5 ;
102390   Dali::ImageDimensions *argp2 ;
102391   Dali::ImageDimensions result;
102392
102393   if (!jarg1) {
102394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102395     return 0;
102396   }
102397   std::string arg1_str(jarg1);
102398   arg1 = &arg1_str;
102399   argp2 = (Dali::ImageDimensions *)jarg2;
102400   if (!argp2) {
102401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102402     return 0;
102403   }
102404   arg2 = *argp2;
102405   arg3 = (Dali::FittingMode::Type)jarg3;
102406   arg4 = (Dali::SamplingMode::Type)jarg4;
102407   arg5 = jarg5 ? true : false;
102408   {
102409     try {
102410       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102411     } catch (std::out_of_range& e) {
102412       {
102413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102414       };
102415     } catch (std::exception& e) {
102416       {
102417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102418       };
102419     } catch (...) {
102420       {
102421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102422       };
102423     }
102424   }
102425   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102426
102427   return jresult;
102428 }
102429
102430
102431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102432   void * jresult ;
102433   std::string *arg1 = 0 ;
102434   Dali::ImageDimensions arg2 ;
102435   Dali::FittingMode::Type arg3 ;
102436   Dali::SamplingMode::Type arg4 ;
102437   Dali::ImageDimensions *argp2 ;
102438   Dali::ImageDimensions result;
102439
102440   if (!jarg1) {
102441     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102442     return 0;
102443   }
102444   std::string arg1_str(jarg1);
102445   arg1 = &arg1_str;
102446   argp2 = (Dali::ImageDimensions *)jarg2;
102447   if (!argp2) {
102448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102449     return 0;
102450   }
102451   arg2 = *argp2;
102452   arg3 = (Dali::FittingMode::Type)jarg3;
102453   arg4 = (Dali::SamplingMode::Type)jarg4;
102454   {
102455     try {
102456       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
102457     } catch (std::out_of_range& e) {
102458       {
102459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102460       };
102461     } catch (std::exception& e) {
102462       {
102463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102464       };
102465     } catch (...) {
102466       {
102467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102468       };
102469     }
102470   }
102471   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102472
102473   return jresult;
102474 }
102475
102476
102477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102478   void * jresult ;
102479   std::string *arg1 = 0 ;
102480   Dali::ImageDimensions arg2 ;
102481   Dali::FittingMode::Type arg3 ;
102482   Dali::ImageDimensions *argp2 ;
102483   Dali::ImageDimensions result;
102484
102485   if (!jarg1) {
102486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102487     return 0;
102488   }
102489   std::string arg1_str(jarg1);
102490   arg1 = &arg1_str;
102491   argp2 = (Dali::ImageDimensions *)jarg2;
102492   if (!argp2) {
102493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102494     return 0;
102495   }
102496   arg2 = *argp2;
102497   arg3 = (Dali::FittingMode::Type)jarg3;
102498   {
102499     try {
102500       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
102501     } catch (std::out_of_range& e) {
102502       {
102503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102504       };
102505     } catch (std::exception& e) {
102506       {
102507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102508       };
102509     } catch (...) {
102510       {
102511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102512       };
102513     }
102514   }
102515   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102516
102517   return jresult;
102518 }
102519
102520
102521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
102522   void * jresult ;
102523   std::string *arg1 = 0 ;
102524   Dali::ImageDimensions arg2 ;
102525   Dali::ImageDimensions *argp2 ;
102526   Dali::ImageDimensions result;
102527
102528   if (!jarg1) {
102529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102530     return 0;
102531   }
102532   std::string arg1_str(jarg1);
102533   arg1 = &arg1_str;
102534   argp2 = (Dali::ImageDimensions *)jarg2;
102535   if (!argp2) {
102536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102537     return 0;
102538   }
102539   arg2 = *argp2;
102540   {
102541     try {
102542       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
102543     } catch (std::out_of_range& e) {
102544       {
102545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102546       };
102547     } catch (std::exception& e) {
102548       {
102549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102550       };
102551     } catch (...) {
102552       {
102553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102554       };
102555     }
102556   }
102557   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102558
102559   return jresult;
102560 }
102561
102562
102563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
102564   void * jresult ;
102565   std::string *arg1 = 0 ;
102566   Dali::ImageDimensions result;
102567
102568   if (!jarg1) {
102569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102570     return 0;
102571   }
102572   std::string arg1_str(jarg1);
102573   arg1 = &arg1_str;
102574   {
102575     try {
102576       result = Dali::GetClosestImageSize((std::string const &)*arg1);
102577     } catch (std::out_of_range& e) {
102578       {
102579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102580       };
102581     } catch (std::exception& e) {
102582       {
102583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102584       };
102585     } catch (...) {
102586       {
102587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102588       };
102589     }
102590   }
102591   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102592
102593   return jresult;
102594 }
102595
102596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
102597   void * jresult ;
102598   std::string *arg1 = 0 ;
102599   Dali::ImageDimensions result;
102600
102601   if (!jarg1) {
102602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102603     return 0;
102604   }
102605   std::string arg1_str(jarg1);
102606   arg1 = &arg1_str;
102607   {
102608     try {
102609       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
102610     } catch (std::out_of_range& e) {
102611       {
102612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102613       };
102614     } catch (std::exception& e) {
102615       {
102616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102617       };
102618     } catch (...) {
102619       {
102620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102621       };
102622     }
102623   }
102624   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
102625
102626   return jresult;
102627 }
102628
102629 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
102630   void * jresult ;
102631   std::string *arg1 = 0 ;
102632   Dali::ImageDimensions arg2 ;
102633   Dali::FittingMode::Type arg3 ;
102634   Dali::SamplingMode::Type arg4 ;
102635   bool arg5 ;
102636   Dali::ImageDimensions *argp2 ;
102637   Dali::Devel::PixelBuffer result;
102638
102639   if (!jarg1) {
102640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102641     return 0;
102642   }
102643   std::string arg1_str(jarg1);
102644   arg1 = &arg1_str;
102645   argp2 = (Dali::ImageDimensions *)jarg2;
102646   if (!argp2) {
102647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102648     return 0;
102649   }
102650   arg2 = *argp2;
102651   arg3 = (Dali::FittingMode::Type)jarg3;
102652   arg4 = (Dali::SamplingMode::Type)jarg4;
102653   arg5 = jarg5 ? true : false;
102654   {
102655     try {
102656       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
102657     } catch (std::out_of_range& e) {
102658       {
102659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102660       };
102661     } catch (std::exception& e) {
102662       {
102663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102664       };
102665     } catch (...) {
102666       {
102667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102668       };
102669     }
102670   }
102671   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102672
102673   return jresult;
102674 }
102675
102676
102677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
102678   void * jresult ;
102679   std::string *arg1 = 0 ;
102680   Dali::ImageDimensions arg2 ;
102681   Dali::FittingMode::Type arg3 ;
102682   Dali::SamplingMode::Type arg4 ;
102683   Dali::ImageDimensions *argp2 ;
102684   Dali::Devel::PixelBuffer result;
102685
102686   if (!jarg1) {
102687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102688     return 0;
102689   }
102690   std::string arg1_str(jarg1);
102691   arg1 = &arg1_str;
102692   argp2 = (Dali::ImageDimensions *)jarg2;
102693   if (!argp2) {
102694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102695     return 0;
102696   }
102697   arg2 = *argp2;
102698   arg3 = (Dali::FittingMode::Type)jarg3;
102699   arg4 = (Dali::SamplingMode::Type)jarg4;
102700   {
102701     try {
102702       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
102703     } catch (std::out_of_range& e) {
102704       {
102705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102706       };
102707     } catch (std::exception& e) {
102708       {
102709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102710       };
102711     } catch (...) {
102712       {
102713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102714       };
102715     }
102716   }
102717   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102718
102719   return jresult;
102720 }
102721
102722
102723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
102724   void * jresult ;
102725   std::string *arg1 = 0 ;
102726   Dali::ImageDimensions arg2 ;
102727   Dali::FittingMode::Type arg3 ;
102728   Dali::ImageDimensions *argp2 ;
102729   Dali::Devel::PixelBuffer result;
102730
102731   if (!jarg1) {
102732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102733     return 0;
102734   }
102735   std::string arg1_str(jarg1);
102736   arg1 = &arg1_str;
102737   argp2 = (Dali::ImageDimensions *)jarg2;
102738   if (!argp2) {
102739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102740     return 0;
102741   }
102742   arg2 = *argp2;
102743   arg3 = (Dali::FittingMode::Type)jarg3;
102744   {
102745     try {
102746       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
102747     } catch (std::out_of_range& e) {
102748       {
102749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102750       };
102751     } catch (std::exception& e) {
102752       {
102753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102754       };
102755     } catch (...) {
102756       {
102757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102758       };
102759     }
102760   }
102761   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102762
102763   return jresult;
102764 }
102765
102766
102767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
102768   void * jresult ;
102769   std::string *arg1 = 0 ;
102770   Dali::ImageDimensions arg2 ;
102771   Dali::ImageDimensions *argp2 ;
102772   Dali::Devel::PixelBuffer result;
102773
102774   if (!jarg1) {
102775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102776     return 0;
102777   }
102778   std::string arg1_str(jarg1);
102779   arg1 = &arg1_str;
102780   argp2 = (Dali::ImageDimensions *)jarg2;
102781   if (!argp2) {
102782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
102783     return 0;
102784   }
102785   arg2 = *argp2;
102786   {
102787     try {
102788       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
102789     } catch (std::out_of_range& e) {
102790       {
102791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102792       };
102793     } catch (std::exception& e) {
102794       {
102795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102796       };
102797     } catch (...) {
102798       {
102799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102800       };
102801     }
102802   }
102803   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102804
102805   return jresult;
102806 }
102807
102808
102809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
102810   void * jresult ;
102811   std::string *arg1 = 0 ;
102812   Dali::Devel::PixelBuffer result;
102813
102814   if (!jarg1) {
102815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
102816     return 0;
102817   }
102818   std::string arg1_str(jarg1);
102819   arg1 = &arg1_str;
102820   {
102821     try {
102822       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
102823     } catch (std::out_of_range& e) {
102824       {
102825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102826       };
102827     } catch (std::exception& e) {
102828       {
102829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102830       };
102831     } catch (...) {
102832       {
102833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102834       };
102835     }
102836   }
102837   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
102838
102839   return jresult;
102840 }
102841
102842
102843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
102844   void * jresult ;
102845   Dali::Toolkit::WebView result;
102846
102847   {
102848     try {
102849       result = Dali::Toolkit::WebView::New();
102850     } catch (std::out_of_range& e) {
102851       {
102852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102853       };
102854     } catch (std::exception& e) {
102855       {
102856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102857       };
102858     } catch (Dali::DaliException e) {
102859       {
102860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102861       };
102862     } catch (...) {
102863       {
102864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102865       };
102866     }
102867   }
102868   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102869   return jresult;
102870 }
102871
102872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
102873   void * jresult ;
102874   Dali::Toolkit::WebView result;
102875
102876   std::string *arg1;
102877   std::string *arg2;
102878
102879   if (!jarg1) {
102880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
102881     return 0;
102882   }
102883   if (!jarg2) {
102884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
102885     return 0;
102886   }
102887
102888   std::string jarg1_str = std::string(jarg1);
102889   std::string jarg2_str = std::string(jarg2);
102890
102891   arg1 = &jarg1_str;
102892   arg2 = &jarg2_str;
102893
102894   {
102895     try {
102896       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
102897     } catch (std::out_of_range& e) {
102898       {
102899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102900       };
102901     } catch (std::exception& e) {
102902       {
102903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
102904       };
102905     } catch (Dali::DaliException e) {
102906       {
102907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
102908       };
102909     } catch (...) {
102910       {
102911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
102912       };
102913     }
102914   }
102915   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
102916   return jresult;
102917 }
102918
102919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
102920   void * jresult ;
102921   Dali::Toolkit::WebView *arg1 = 0 ;
102922   Dali::Toolkit::WebView *result = 0 ;
102923
102924   arg1 = (Dali::Toolkit::WebView *)jarg1;
102925   if (!arg1) {
102926     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102927     return 0;
102928   }
102929   {
102930     try {
102931       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
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 = (void *)result;
102951   return jresult;
102952 }
102953
102954 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
102955   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102956   arg1 = (Dali::Toolkit::WebView *)jarg1;
102957   {
102958     try {
102959       delete arg1;
102960     } catch (std::out_of_range& e) {
102961       {
102962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
102963       };
102964     } catch (std::exception& e) {
102965       {
102966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
102967       };
102968     } catch (Dali::DaliException e) {
102969       {
102970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
102971       };
102972     } catch (...) {
102973       {
102974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
102975       };
102976     }
102977   }
102978 }
102979
102980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
102981   void * jresult ;
102982   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
102983   Dali::Toolkit::WebView *arg2 = 0 ;
102984   Dali::Toolkit::WebView *result = 0 ;
102985
102986   arg1 = (Dali::Toolkit::WebView *)jarg1;
102987   arg2 = (Dali::Toolkit::WebView *)jarg2;
102988   if (!arg2) {
102989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
102990     return 0;
102991   }
102992   {
102993     try {
102994       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
102995     } catch (std::out_of_range& e) {
102996       {
102997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
102998       };
102999     } catch (std::exception& e) {
103000       {
103001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103002       };
103003     } catch (Dali::DaliException e) {
103004       {
103005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103006       };
103007     } catch (...) {
103008       {
103009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103010       };
103011     }
103012   }
103013   jresult = (void *)result;
103014   return jresult;
103015 }
103016
103017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
103018   void * jresult ;
103019   Dali::BaseHandle arg1 ;
103020   Dali::BaseHandle *argp1 ;
103021   Dali::Toolkit::WebView result;
103022
103023   argp1 = (Dali::BaseHandle *)jarg1;
103024   if (!argp1) {
103025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
103026     return 0;
103027   }
103028   arg1 = *argp1;
103029   {
103030     try {
103031       result = Dali::Toolkit::WebView::DownCast(arg1);
103032     } catch (std::out_of_range& e) {
103033       {
103034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103035       };
103036     } catch (std::exception& e) {
103037       {
103038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103039       };
103040     } catch (Dali::DaliException e) {
103041       {
103042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103043       };
103044     } catch (...) {
103045       {
103046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103047       };
103048     }
103049   }
103050   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
103051   return jresult;
103052 }
103053
103054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
103055   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103056   std::string *arg2;
103057
103058   arg1 = (Dali::Toolkit::WebView *)jarg1;
103059
103060   if (!jarg2) {
103061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103062     return;
103063   }
103064
103065   std::string jarg2str = std::string(jarg2);
103066   arg2 = &jarg2str;
103067   {
103068     try {
103069       (arg1)->LoadUrl((std::string const &)*arg2);
103070     } catch (std::out_of_range& e) {
103071       {
103072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103073       };
103074     } catch (std::exception& e) {
103075       {
103076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103077       };
103078     } catch (Dali::DaliException e) {
103079       {
103080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103081       };
103082     } catch (...) {
103083       {
103084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103085       };
103086     }
103087   }
103088 }
103089
103090 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_WebView_GetUrl(void * jarg1) {
103091   char * jresult ;
103092   std::string result;
103093
103094   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103095
103096   arg1 = (Dali::Toolkit::WebView *)jarg1;
103097   {
103098     try {
103099       result = arg1->GetUrl();
103100     } catch (std::out_of_range& e) {
103101       {
103102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103103       };
103104     } catch (std::exception& e) {
103105       {
103106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103107       };
103108     } catch (Dali::DaliException e) {
103109       {
103110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103111       };
103112     } catch (...) {
103113       {
103114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103115       };
103116     }
103117   }
103118
103119   jresult = SWIG_csharp_string_callback((&result)->c_str());
103120   return jresult;
103121 }
103122
103123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
103124   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103125   std::string *arg2;
103126
103127   arg1 = (Dali::Toolkit::WebView *)jarg1;
103128   if (!jarg2) {
103129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103130     return;
103131   }
103132   std::string jarg2str = std::string(jarg2);
103133   arg2 = &jarg2str;
103134   {
103135     try {
103136       (arg1)->LoadHTMLString((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_Reload(void * jarg1) {
103158   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103159
103160   arg1 = (Dali::Toolkit::WebView *)jarg1;
103161   {
103162     try {
103163       (arg1)->Reload();
103164     } catch (std::out_of_range& e) {
103165       {
103166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103167       };
103168     } catch (std::exception& e) {
103169       {
103170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103171       };
103172     } catch (Dali::DaliException e) {
103173       {
103174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103175       };
103176     } catch (...) {
103177       {
103178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103179       };
103180     }
103181   }
103182 }
103183
103184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
103185   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103186
103187   arg1 = (Dali::Toolkit::WebView *)jarg1;
103188   {
103189     try {
103190       (arg1)->StopLoading();
103191     } catch (std::out_of_range& e) {
103192       {
103193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103194       };
103195     } catch (std::exception& e) {
103196       {
103197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103198       };
103199     } catch (Dali::DaliException e) {
103200       {
103201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103202       };
103203     } catch (...) {
103204       {
103205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103206       };
103207     }
103208   }
103209 }
103210
103211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
103212   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103213
103214   arg1 = (Dali::Toolkit::WebView *)jarg1;
103215   {
103216     try {
103217       (arg1)->GoBack();
103218     } catch (std::out_of_range& e) {
103219       {
103220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103221       };
103222     } catch (std::exception& e) {
103223       {
103224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103225       };
103226     } catch (Dali::DaliException e) {
103227       {
103228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103229       };
103230     } catch (...) {
103231       {
103232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103233       };
103234     }
103235   }
103236 }
103237
103238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
103239   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103240
103241   arg1 = (Dali::Toolkit::WebView *)jarg1;
103242   {
103243     try {
103244       (arg1)->GoForward();
103245     } catch (std::out_of_range& e) {
103246       {
103247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103248       };
103249     } catch (std::exception& e) {
103250       {
103251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103252       };
103253     } catch (Dali::DaliException e) {
103254       {
103255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103256       };
103257     } catch (...) {
103258       {
103259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103260       };
103261     }
103262   }
103263 }
103264
103265 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
103266   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103267   bool ret;
103268
103269   arg1 = (Dali::Toolkit::WebView *)jarg1;
103270   {
103271     try {
103272       ret = (arg1)->CanGoBack();
103273     } catch (std::out_of_range& e) {
103274       {
103275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103276       };
103277     } catch (std::exception& e) {
103278       {
103279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103280       };
103281     } catch (Dali::DaliException e) {
103282       {
103283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103284       };
103285     } catch (...) {
103286       {
103287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103288       };
103289     }
103290   }
103291   return ret;
103292 }
103293
103294 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
103295   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103296   bool ret;
103297
103298   arg1 = (Dali::Toolkit::WebView *)jarg1;
103299   {
103300     try {
103301       ret = (arg1)->CanGoForward();
103302     } catch (std::out_of_range& e) {
103303       {
103304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
103305       };
103306     } catch (std::exception& e) {
103307       {
103308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
103309       };
103310     } catch (Dali::DaliException e) {
103311       {
103312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
103313       };
103314     } catch (...) {
103315       {
103316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
103317       };
103318     }
103319   }
103320   return ret;
103321 }
103322
103323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2) {
103324   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103325   std::string *arg2;
103326
103327   arg1 = (Dali::Toolkit::WebView *)jarg1;
103328   if (!jarg2) {
103329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103330     return;
103331   }
103332   std::string jarg2_str = std::string(jarg2);
103333   arg2 = &jarg2_str;
103334   {
103335     try {
103336       (arg1)->EvaluateJavaScript((std::string const &)*arg2);
103337     } catch (std::out_of_range& e) {
103338       {
103339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103340       };
103341     } catch (std::exception& e) {
103342       {
103343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103344       };
103345     } catch (Dali::DaliException e) {
103346       {
103347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103348       };
103349     } catch (...) {
103350       {
103351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103352       };
103353     }
103354   }
103355 }
103356
103357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
103358 {
103359   if (!jarg2) {
103360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
103361     return;
103362   }
103363
103364   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103365   std::string exposedObjectName = jarg2;
103366   void (*handler)(char*) = (void (*)(char*)) jarg3;
103367
103368   {
103369     try {
103370       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
103371         handler(SWIG_csharp_string_callback(message.c_str()));
103372       });
103373     } catch (std::out_of_range& e) {
103374       {
103375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103376       };
103377     } catch (std::exception& e) {
103378       {
103379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103380       };
103381     } catch (Dali::DaliException e) {
103382       {
103383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103384       };
103385     } catch (...) {
103386       {
103387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103388       };
103389     }
103390   }
103391 }
103392
103393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
103394   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103395
103396   arg1 = (Dali::Toolkit::WebView *)jarg1;
103397   {
103398     try {
103399       (arg1)->ClearHistory();
103400     } catch (std::out_of_range& e) {
103401       {
103402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103403       };
103404     } catch (std::exception& e) {
103405       {
103406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103407       };
103408     } catch (Dali::DaliException e) {
103409       {
103410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103411       };
103412     } catch (...) {
103413       {
103414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103415       };
103416     }
103417   }
103418 }
103419
103420 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
103421   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
103422
103423   arg1 = (Dali::Toolkit::WebView *)jarg1;
103424   {
103425     try {
103426       (arg1)->ClearCache();
103427     } catch (std::out_of_range& e) {
103428       {
103429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103430       };
103431     } catch (std::exception& e) {
103432       {
103433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103434       };
103435     } catch (Dali::DaliException e) {
103436       {
103437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103438       };
103439     } catch (...) {
103440       {
103441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103442       };
103443     }
103444   }
103445 }
103446
103447 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
103448     return (Dali::Toolkit::Control *)jarg1;
103449 }
103450
103451
103452 // Proxy class of WebViewSignal.
103453 // WebViewSignal has an argument of std::string type which is not supported at C# side.
103454 // The purpose of this class is to convert signal argument of string type safely.
103455 class WebViewSignalProxy : public ConnectionTracker
103456 {
103457 public:
103458   typedef Dali::Signal< void(Dali::Toolkit::WebView, const std::string&) > OriginalSignalType;
103459   typedef Dali::Signal< void(Dali::Toolkit::WebView, char*) > ProxySignalType;
103460   typedef void (*CallbackType)(Dali::Toolkit::WebView, char *);
103461
103462   WebViewSignalProxy(OriginalSignalType* signal)
103463     : mSignalPtr(signal)
103464   {
103465   }
103466
103467   void Connect(CallbackType csharpCallback)
103468   {
103469     if (mSignalPtr->Empty())
103470     {
103471       mSignalPtr->Connect(this, &WebViewSignalProxy::OnEmit);
103472     }
103473     mProxySignal.Connect(csharpCallback);
103474   }
103475
103476   void Disconnect(CallbackType csharpCallback)
103477   {
103478     mProxySignal.Disconnect(csharpCallback);
103479     if (mProxySignal.Empty())
103480     {
103481       mSignalPtr->Disconnect(this, &WebViewSignalProxy::OnEmit);
103482     }
103483   }
103484
103485   bool Empty()
103486   {
103487     return mProxySignal.Empty();
103488   }
103489
103490   std::size_t GetConnectionCount()
103491   {
103492     return mProxySignal.GetConnectionCount();
103493   }
103494
103495   void Emit(Dali::Toolkit::WebView& webview, char* url)
103496   {
103497     if (!mProxySignal.Empty())
103498     {
103499       mProxySignal.Emit(webview, url);
103500     }
103501   }
103502
103503   void OnEmit(Dali::Toolkit::WebView webview, const std::string& url)
103504   {
103505     // Safe string conversion
103506     mProxySignal.Emit(webview, SWIG_csharp_string_callback(url.c_str()));
103507   }
103508
103509 private:
103510   OriginalSignalType* mSignalPtr;
103511   ProxySignalType mProxySignal;
103512 };
103513
103514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadStarted(void * jarg1) {
103515   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103516   WebViewSignalProxy* result = NULL;
103517   {
103518     try {
103519       result = new WebViewSignalProxy(&webview->PageLoadStartedSignal());
103520     } catch (std::out_of_range& e) {
103521       {
103522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103523       };
103524     } catch (std::exception& e) {
103525       {
103526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103527       };
103528     } catch (Dali::DaliException e) {
103529       {
103530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103531       };
103532     } catch (...) {
103533       {
103534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103535       };
103536     }
103537   }
103538   return (void*) result;
103539 }
103540
103541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewSignalProxy_PageLoadFinished(void * jarg1) {
103542   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
103543   WebViewSignalProxy* result = NULL;
103544   {
103545     try {
103546       result = new WebViewSignalProxy(&webview->PageLoadFinishedSignal());
103547     } catch (std::out_of_range& e) {
103548       {
103549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103550       };
103551     } catch (std::exception& e) {
103552       {
103553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103554       };
103555     } catch (Dali::DaliException e) {
103556       {
103557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103558       };
103559     } catch (...) {
103560       {
103561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103562       };
103563     }
103564   }
103565   return (void*) result;
103566 }
103567
103568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewSignalProxy(void * jarg1)
103569 {
103570   WebViewSignalProxy* object = (WebViewSignalProxy*) jarg1;
103571   {
103572     try {
103573       delete object;
103574     } catch (std::out_of_range& e) {
103575       {
103576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103577       };
103578     } catch (std::exception& e) {
103579       {
103580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103581       };
103582     } catch (Dali::DaliException e) {
103583       {
103584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103585       };
103586     } catch (...) {
103587       {
103588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103589       };
103590     }
103591   }
103592 }
103593
103594 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Empty(void * jarg1)
103595 {
103596   bool result;
103597   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103598   {
103599     try {
103600       result = (bool)proxy->Empty();
103601     } catch (std::out_of_range& e) {
103602       {
103603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103604       };
103605     } catch (std::exception& e) {
103606       {
103607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103608       };
103609     } catch (Dali::DaliException e) {
103610       {
103611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103612       };
103613     } catch (...) {
103614       {
103615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103616       };
103617     }
103618   }
103619   return (unsigned int) result;
103620 }
103621
103622
103623 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_GetConnectionCount(void * jarg1)
103624 {
103625   std::size_t result;
103626   WebViewSignalProxy* arg1 = (WebViewSignalProxy*) jarg1;
103627   {
103628     try {
103629       result = arg1->GetConnectionCount();
103630     } catch (std::out_of_range& e) {
103631       {
103632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
103633       };
103634     } catch (std::exception& e) {
103635       {
103636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
103637       };
103638     } catch (Dali::DaliException e) {
103639       {
103640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
103641       };
103642     } catch (...) {
103643       {
103644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
103645       };
103646     }
103647   }
103648   return (unsigned long) result;
103649 }
103650
103651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Connect(void * jarg1, void * jarg2)
103652 {
103653   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103654   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::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_WebViewSignalProxy_Disconnect(void * jarg1, void * jarg2) {
103680   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103681   WebViewSignalProxy::CallbackType callback = (WebViewSignalProxy::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
103706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewSignalProxy_Emit(void * jarg1, void * jarg2, char * jarg3) {
103707   if (!jarg2) {
103708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView & type is null", 0);
103709     return ;
103710   }
103711   if (!jarg3) {
103712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg3 is null string", 0);
103713     return ;
103714   }
103715
103716   WebViewSignalProxy* proxy = (WebViewSignalProxy*) jarg1;
103717   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView*) jarg2;
103718   {
103719     try {
103720       proxy->Emit(*webview, jarg3);
103721     } catch (std::out_of_range& e) {
103722       {
103723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
103724       };
103725     } catch (std::exception& e) {
103726       {
103727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
103728       };
103729     } catch (Dali::DaliException e) {
103730       {
103731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
103732       };
103733     } catch (...) {
103734       {
103735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
103736       };
103737     }
103738   }
103739 }
103740
103741 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
103742   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
103743   char * jresult = SWIG_csharp_string_callback((const char *)result);
103744   return jresult;
103745 }
103746
103747 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
103748   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
103749   return result;
103750 }
103751
103752 #ifdef __cplusplus
103753 }
103754 #endif
103755